@cohaku/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1380 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { join } from "path";
+import { homedir } from "os";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../core/dist/storage/sqlite-driver.js
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+
+// ../shared/dist/constants.js
+var DEFAULT_WEIGHTS = {
+  semantic: 0.4,
+  bm25: 0.25,
+  recency: 0.2,
+  salience: 0.15
+};
+var MEMORY_LAYER_PRIORITY = {
+  rule: 10,
+  working: 5,
+  long_term: 1
+};
+var DEFAULT_DECAY_RATE = 0.01;
+var DEFAULT_EMBEDDING_DIMENSIONS = 384;
+
+// ../core/dist/storage/schema.js
+var SCHEMA_VERSION = 1;
+var CREATE_TABLES = `
+  -- Memory (3-layer)
+  CREATE TABLE IF NOT EXISTS memories (
+    id TEXT PRIMARY KEY,
+    content TEXT NOT NULL,
+    layer TEXT NOT NULL DEFAULT 'long_term',
+    type TEXT NOT NULL DEFAULT 'note',
+    priority INTEGER NOT NULL DEFAULT 1,
+    importance REAL NOT NULL DEFAULT 0.5,
+    tags TEXT,
+    expires_at TEXT,
+    last_accessed_at TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    deleted_at TEXT
+  );
+
+  -- FTS5 virtual table (BM25 search)
+  CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+    content,
+    tags,
+    content='memories',
+    content_rowid='rowid',
+    tokenize='porter'
+  );
+
+  -- FTS5 sync triggers
+  CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+    INSERT INTO memories_fts(rowid, content, tags)
+    VALUES (new.rowid, new.content, new.tags);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content, tags)
+    VALUES ('delete', old.rowid, old.content, old.tags);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content, tags)
+    VALUES ('delete', old.rowid, old.content, old.tags);
+    INSERT INTO memories_fts(rowid, content, tags)
+    VALUES (new.rowid, new.content, new.tags);
+  END;
+
+  -- Entity nodes
+  CREATE TABLE IF NOT EXISTS nodes (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    name_embedding BLOB,
+    summary TEXT,
+    entity_type TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  -- Edges (bi-temporal)
+  CREATE TABLE IF NOT EXISTS edges (
+    id TEXT PRIMARY KEY,
+    source_id TEXT NOT NULL REFERENCES nodes(id),
+    target_id TEXT NOT NULL REFERENCES nodes(id),
+    relation TEXT NOT NULL,
+    fact TEXT,
+    fact_embedding BLOB,
+    created_at TEXT NOT NULL,
+    expired_at TEXT,
+    valid_at TEXT,
+    invalid_at TEXT
+  );
+
+  -- Episodes
+  CREATE TABLE IF NOT EXISTS episodes (
+    id TEXT PRIMARY KEY,
+    content TEXT NOT NULL,
+    content_type TEXT,
+    source TEXT,
+    created_at TEXT NOT NULL
+  );
+
+  -- Episode references
+  CREATE TABLE IF NOT EXISTS episode_refs (
+    episode_id TEXT REFERENCES episodes(id),
+    ref_type TEXT,
+    ref_id TEXT,
+    PRIMARY KEY (episode_id, ref_type, ref_id)
+  );
+
+  -- Sessions
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    status TEXT NOT NULL DEFAULT 'active',
+    started_at TEXT NOT NULL,
+    ended_at TEXT,
+    checkpoint_count INTEGER NOT NULL DEFAULT 0,
+    working_memory_snapshot TEXT,
+    metadata TEXT
+  );
+
+  -- Config
+  CREATE TABLE IF NOT EXISTS config (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+
+  -- Indexes
+  CREATE INDEX IF NOT EXISTS idx_memories_layer ON memories(layer);
+  CREATE INDEX IF NOT EXISTS idx_memories_deleted ON memories(deleted_at);
+  CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+  CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+  CREATE INDEX IF NOT EXISTS idx_edges_expired ON edges(expired_at);
+  CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+`;
+function createVecTables(dimensions) {
+  return `
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
+      memory_id TEXT PRIMARY KEY,
+      embedding float[${dimensions}]
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_nodes USING vec0(
+      node_id TEXT PRIMARY KEY,
+      embedding float[${dimensions}]
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_edges USING vec0(
+      edge_id TEXT PRIMARY KEY,
+      embedding float[${dimensions}]
+    );
+  `;
+}
+
+// ../core/dist/utils/temporal.js
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toVecBlob(embedding) {
+  return Buffer.from(new Float32Array(embedding).buffer);
+}
+
+// ../core/dist/storage/sqlite-driver.js
+var SqliteDriver = class {
+  dbPath;
+  dimensions;
+  db;
+  constructor(dbPath2, dimensions = DEFAULT_EMBEDDING_DIMENSIONS) {
+    this.dbPath = dbPath2;
+    this.dimensions = dimensions;
+  }
+  async initialize() {
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    sqliteVec.load(this.db);
+    this.db.exec(CREATE_TABLES);
+    const vecSQL = createVecTables(this.dimensions);
+    for (const stmt of vecSQL.split(";").filter((s) => s.trim())) {
+      this.db.exec(stmt);
+    }
+    const existing = this.db.prepare("SELECT value FROM config WHERE key = ?").get("schema_version");
+    if (!existing) {
+      this.db.prepare("INSERT INTO config (key, value) VALUES (?, ?)").run("schema_version", String(SCHEMA_VERSION));
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  // ── Memory ──
+  async addMemory(memory) {
+    const tagsStr = memory.tags ? JSON.stringify(memory.tags) : null;
+    this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT INTO memories (id, content, layer, type, priority, importance, tags, expires_at, last_accessed_at, created_at, updated_at, deleted_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(memory.id, memory.content, memory.layer, memory.type, memory.priority, memory.importance, tagsStr, memory.expiresAt ?? null, memory.lastAccessedAt, memory.createdAt, memory.updatedAt, memory.deletedAt ?? null);
+      if (memory.embedding) {
+        this.db.prepare(`
+          INSERT INTO vec_memories (memory_id, embedding) VALUES (?, ?)
+        `).run(memory.id, toVecBlob(memory.embedding));
+      }
+    })();
+  }
+  async getMemory(id) {
+    const row = this.db.prepare("SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL").get(id);
+    return row ? this.rowToMemory(row) : null;
+  }
+  async updateMemory(id, input) {
+    const sets = ["updated_at = ?"];
+    const values = [(/* @__PURE__ */ new Date()).toISOString()];
+    if (input.content !== void 0) {
+      sets.push("content = ?");
+      values.push(input.content);
+    }
+    if (input.layer !== void 0) {
+      sets.push("layer = ?");
+      values.push(input.layer);
+    }
+    if (input.type !== void 0) {
+      sets.push("type = ?");
+      values.push(input.type);
+    }
+    if (input.importance !== void 0) {
+      sets.push("importance = ?");
+      values.push(input.importance);
+    }
+    if (input.tags !== void 0) {
+      sets.push("tags = ?");
+      values.push(JSON.stringify(input.tags));
+    }
+    if (input.expiresAt !== void 0) {
+      sets.push("expires_at = ?");
+      values.push(input.expiresAt);
+    }
+    values.push(id);
+    this.db.prepare(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+  }
+  async updateMemoryEmbedding(id, embedding) {
+    this.db.transaction(() => {
+      this.db.prepare("DELETE FROM vec_memories WHERE memory_id = ?").run(id);
+      this.db.prepare("INSERT INTO vec_memories (memory_id, embedding) VALUES (?, ?)").run(id, toVecBlob(embedding));
+    })();
+  }
+  async deleteMemory(id) {
+    this.db.prepare("UPDATE memories SET deleted_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  async searchMemories(embedding, limit) {
+    const rows = this.db.prepare(`
+      SELECT m.*, v.distance
+      FROM vec_memories v
+      INNER JOIN memories m ON m.id = v.memory_id
+      WHERE v.embedding MATCH ?
+        AND m.deleted_at IS NULL
+        AND k = ?
+    `).all(toVecBlob(embedding), limit);
+    return rows.map((row) => ({
+      memory: this.rowToMemory(row),
+      distance: row.distance
+    }));
+  }
+  async fullTextSearch(query, limit) {
+    const rows = this.db.prepare(`
+      SELECT m.*, fts.rank
+      FROM memories_fts fts
+      INNER JOIN memories m ON m.rowid = fts.rowid
+      WHERE memories_fts MATCH ?
+        AND m.deleted_at IS NULL
+      ORDER BY fts.rank
+      LIMIT ?
+    `).all(query, limit);
+    return rows.map((row) => ({
+      memory: this.rowToMemory(row),
+      rank: row.rank
+    }));
+  }
+  async findSimilarMemories(embedding, threshold, limit) {
+    const results = await this.searchMemories(embedding, limit * 3);
+    return results.filter((r) => r.distance <= threshold).slice(0, limit);
+  }
+  async listMemoriesByLayer(layer, limit) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE layer = ?
+        AND deleted_at IS NULL
+        AND (expires_at IS NULL OR expires_at > ?)
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(layer, now, limit);
+    return rows.map((row) => this.rowToMemory(row));
+  }
+  // ── Nodes ──
+  async upsertNode(node) {
+    this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT INTO nodes (id, name, summary, entity_type, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          name = excluded.name,
+          summary = excluded.summary,
+          entity_type = excluded.entity_type,
+          updated_at = excluded.updated_at
+      `).run(node.id, node.name, node.summary ?? null, node.entityType ?? null, node.createdAt, node.updatedAt);
+      if (node.nameEmbedding) {
+        this.db.prepare(`
+          DELETE FROM vec_nodes WHERE node_id = ?
+        `).run(node.id);
+        this.db.prepare(`
+          INSERT INTO vec_nodes (node_id, embedding) VALUES (?, ?)
+        `).run(node.id, toVecBlob(node.nameEmbedding));
+      }
+    })();
+  }
+  async getNode(id) {
+    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
+    return row ? this.rowToNode(row) : null;
+  }
+  async searchNodes(embedding, limit) {
+    const rows = this.db.prepare(`
+      SELECT n.*
+      FROM vec_nodes v
+      INNER JOIN nodes n ON n.id = v.node_id
+      WHERE v.embedding MATCH ?
+        AND k = ?
+    `).all(toVecBlob(embedding), limit);
+    return rows.map((row) => this.rowToNode(row));
+  }
+  // ── Edges ──
+  async upsertEdge(edge) {
+    this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT INTO edges (id, source_id, target_id, relation, fact, created_at, expired_at, valid_at, invalid_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          relation = excluded.relation,
+          fact = excluded.fact,
+          expired_at = excluded.expired_at,
+          valid_at = excluded.valid_at,
+          invalid_at = excluded.invalid_at
+      `).run(edge.id, edge.sourceId, edge.targetId, edge.relation, edge.fact ?? null, edge.createdAt, edge.expiredAt ?? null, edge.validAt ?? null, edge.invalidAt ?? null);
+      if (edge.factEmbedding) {
+        this.db.prepare(`
+          DELETE FROM vec_edges WHERE edge_id = ?
+        `).run(edge.id);
+        this.db.prepare(`
+          INSERT INTO vec_edges (edge_id, embedding) VALUES (?, ?)
+        `).run(edge.id, toVecBlob(edge.factEmbedding));
+      }
+    })();
+  }
+  async getEdge(id) {
+    const row = this.db.prepare("SELECT * FROM edges WHERE id = ?").get(id);
+    return row ? this.rowToEdge(row) : null;
+  }
+  async invalidateEdge(id, expiredAt, invalidAt) {
+    this.db.prepare("UPDATE edges SET expired_at = ?, invalid_at = ? WHERE id = ?").run(expiredAt, invalidAt, id);
+  }
+  async searchEdges(embedding, filters, limit) {
+    let whereClause = "1=1";
+    const params = [toVecBlob(embedding), limit];
+    if (filters.excludeExpired !== false) {
+      whereClause += " AND e.expired_at IS NULL";
+    }
+    if (filters.asOf) {
+      whereClause += " AND (e.valid_at IS NULL OR e.valid_at <= ?)";
+      params.push(filters.asOf);
+      whereClause += " AND (e.invalid_at IS NULL OR e.invalid_at > ?)";
+      params.push(filters.asOf);
+    }
+    const rows = this.db.prepare(`
+      SELECT e.*
+      FROM vec_edges v
+      INNER JOIN edges e ON e.id = v.edge_id
+      WHERE v.embedding MATCH ?
+        AND k = ?
+        AND ${whereClause}
+    `).all(...params);
+    return rows.map((row) => this.rowToEdge(row));
+  }
+  // ── Graph Traversal ──
+  async getEdgesForNode(nodeId) {
+    const rows = this.db.prepare(`
+      SELECT * FROM edges
+      WHERE (source_id = ? OR target_id = ?) AND expired_at IS NULL
+    `).all(nodeId, nodeId);
+    return rows.map((row) => this.rowToEdge(row));
+  }
+  async getNeighbors(nodeId, depth) {
+    if (depth < 1)
+      return [];
+    const oneHop = this.db.prepare(`
+      SELECT DISTINCT n.* FROM nodes n
+      INNER JOIN edges e ON (e.source_id = ? AND e.target_id = n.id)
+                         OR (e.target_id = ? AND e.source_id = n.id)
+      WHERE e.expired_at IS NULL
+    `).all(nodeId, nodeId);
+    if (depth === 1) {
+      return oneHop.map((row) => this.rowToNode(row));
+    }
+    const visited = /* @__PURE__ */ new Set([nodeId]);
+    const results = [];
+    for (const row of oneHop) {
+      visited.add(row.id);
+      results.push(this.rowToNode(row));
+    }
+    for (const node of [...results]) {
+      const twoHop = this.db.prepare(`
+        SELECT DISTINCT n.* FROM nodes n
+        INNER JOIN edges e ON (e.source_id = ? AND e.target_id = n.id)
+                           OR (e.target_id = ? AND e.source_id = n.id)
+        WHERE e.expired_at IS NULL
+      `).all(node.id, node.id);
+      for (const row of twoHop) {
+        if (!visited.has(row.id)) {
+          visited.add(row.id);
+          results.push(this.rowToNode(row));
+        }
+      }
+    }
+    return results;
+  }
+  // ── Episodes ──
+  async addEpisode(episode) {
+    this.db.prepare(`
+      INSERT INTO episodes (id, content, content_type, source, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(episode.id, episode.content, episode.contentType ?? null, episode.source ?? null, episode.createdAt);
+  }
+  async addEpisodeRef(ref) {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO episode_refs (episode_id, ref_type, ref_id)
+      VALUES (?, ?, ?)
+    `).run(ref.episodeId, ref.refType, ref.refId);
+  }
+  async getEpisode(id) {
+    const row = this.db.prepare("SELECT * FROM episodes WHERE id = ?").get(id);
+    return row ? this.rowToEpisode(row) : null;
+  }
+  async listEpisodes(limit) {
+    const rows = this.db.prepare("SELECT * FROM episodes ORDER BY created_at DESC LIMIT ?").all(limit);
+    return rows.map((row) => this.rowToEpisode(row));
+  }
+  async getEpisodeRefs(episodeId) {
+    const rows = this.db.prepare("SELECT * FROM episode_refs WHERE episode_id = ?").all(episodeId);
+    return rows.map((row) => ({
+      episodeId: row.episode_id,
+      refType: row.ref_type,
+      refId: row.ref_id
+    }));
+  }
+  // ── Sessions ──
+  async addSession(session) {
+    this.db.prepare(`
+      INSERT INTO sessions (id, status, started_at, ended_at, checkpoint_count, working_memory_snapshot, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(session.id, session.status, session.startedAt, session.endedAt ?? null, session.checkpointCount, session.workingMemorySnapshot ?? null, session.metadata ?? null);
+  }
+  async updateSession(id, updates) {
+    const sets = [];
+    const values = [];
+    if (updates.status !== void 0) {
+      sets.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.endedAt !== void 0) {
+      sets.push("ended_at = ?");
+      values.push(updates.endedAt);
+    }
+    if (updates.checkpointCount !== void 0) {
+      sets.push("checkpoint_count = ?");
+      values.push(updates.checkpointCount);
+    }
+    if (updates.workingMemorySnapshot !== void 0) {
+      sets.push("working_memory_snapshot = ?");
+      values.push(updates.workingMemorySnapshot);
+    }
+    if (updates.metadata !== void 0) {
+      sets.push("metadata = ?");
+      values.push(updates.metadata);
+    }
+    if (sets.length === 0)
+      return;
+    values.push(id);
+    this.db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+  }
+  async getSession(id) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    return row ? this.rowToSession(row) : null;
+  }
+  async listSessions(limit) {
+    const rows = this.db.prepare("SELECT * FROM sessions ORDER BY started_at DESC LIMIT ?").all(limit);
+    return rows.map((row) => this.rowToSession(row));
+  }
+  // ── Config ──
+  async getConfig(key) {
+    const row = this.db.prepare("SELECT value FROM config WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  async setConfig(key, value) {
+    this.db.prepare("INSERT INTO config (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
+  // ── Row Converters ──
+  rowToMemory(row) {
+    return {
+      id: row.id,
+      content: row.content,
+      layer: row.layer,
+      type: row.type,
+      priority: row.priority,
+      importance: row.importance,
+      tags: row.tags ? JSON.parse(row.tags) : void 0,
+      expiresAt: row.expires_at ?? void 0,
+      lastAccessedAt: row.last_accessed_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      deletedAt: row.deleted_at ?? void 0
+    };
+  }
+  rowToNode(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      summary: row.summary ?? void 0,
+      entityType: row.entity_type ?? void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  rowToEdge(row) {
+    return {
+      id: row.id,
+      sourceId: row.source_id,
+      targetId: row.target_id,
+      relation: row.relation,
+      fact: row.fact ?? void 0,
+      createdAt: row.created_at,
+      expiredAt: row.expired_at ?? void 0,
+      validAt: row.valid_at ?? void 0,
+      invalidAt: row.invalid_at ?? void 0
+    };
+  }
+  rowToEpisode(row) {
+    return {
+      id: row.id,
+      content: row.content,
+      contentType: row.content_type ?? void 0,
+      source: row.source ?? void 0,
+      createdAt: row.created_at
+    };
+  }
+  rowToSession(row) {
+    return {
+      id: row.id,
+      status: row.status,
+      startedAt: row.started_at,
+      endedAt: row.ended_at ?? void 0,
+      checkpointCount: row.checkpoint_count,
+      workingMemorySnapshot: row.working_memory_snapshot ?? void 0,
+      metadata: row.metadata ?? void 0
+    };
+  }
+};
+
+// ../core/dist/embedding/local-embedding.js
+var LocalEmbedding = class {
+  cacheDir;
+  dimensions = 384;
+  pipe = null;
+  initPromise = null;
+  constructor(cacheDir) {
+    this.cacheDir = cacheDir;
+  }
+  async getPipeline() {
+    if (this.pipe)
+      return this.pipe;
+    if (!this.initPromise) {
+      this.initPromise = (async () => {
+        const { pipeline, env } = await import("@xenova/transformers");
+        if (this.cacheDir) {
+          env.cacheDir = this.cacheDir;
+        }
+        const pipe = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+        return pipe;
+      })();
+    }
+    this.pipe = await this.initPromise;
+    return this.pipe;
+  }
+  async embed(text) {
+    const pipe = await this.getPipeline();
+    const result = await pipe(text, { pooling: "mean", normalize: true });
+    return Array.from(result.data).slice(0, this.dimensions);
+  }
+  async embedBatch(texts) {
+    return Promise.all(texts.map((t) => this.embed(t)));
+  }
+};
+
+// ../core/dist/engine/memory-engine.js
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+
+// ../core/dist/utils/id.js
+import { nanoid } from "nanoid";
+function generateId() {
+  return nanoid();
+}
+
+// ../core/dist/engine/scoring.js
+function decay(importance, lastAccessedAt, rate = 0.01) {
+  const ageHours = (Date.now() - new Date(lastAccessedAt).getTime()) / 36e5;
+  return importance * Math.exp(-rate * ageHours);
+}
+function recencyScore(timestamp, halfLifeHours = 24) {
+  const ageHours = (Date.now() - new Date(timestamp).getTime()) / 36e5;
+  return Math.exp(-Math.LN2 / halfLifeHours * ageHours);
+}
+function hybridScore(semantic, bm25, recency, salience, weights) {
+  return semantic * weights.semantic + bm25 * weights.bm25 + recency * weights.recency + salience * weights.salience;
+}
+function normalizeBm25(rank) {
+  return 1 / (1 + Math.abs(rank));
+}
+function distanceToSimilarity(distance) {
+  return 1 / (1 + distance);
+}
+
+// ../core/dist/engine/context.js
+async function getContext(storage, options = {}) {
+  const { maxMemories = 50 } = options;
+  const rules = await storage.listMemoriesByLayer("rule", maxMemories);
+  const remaining1 = maxMemories - rules.length;
+  const working = remaining1 > 0 ? await storage.listMemoriesByLayer("working", Math.ceil(remaining1 * 0.6)) : [];
+  const remaining2 = maxMemories - rules.length - working.length;
+  const longTerm = remaining2 > 0 ? await storage.listMemoriesByLayer("long_term", remaining2) : [];
+  const memories = [...rules, ...working, ...longTerm];
+  const totalCount = memories.length;
+  return {
+    memories,
+    totalCount,
+    truncated: totalCount >= maxMemories
+  };
+}
+
+// ../core/dist/engine/memory-engine.js
+var MemoryEngine = class {
+  storage;
+  embedding;
+  weights;
+  decayRate;
+  constructor(config) {
+    mkdirSync(dirname(config.dbPath), { recursive: true });
+    this.storage = new SqliteDriver(config.dbPath);
+    this.embedding = new LocalEmbedding(config.embeddingCacheDir);
+    this.weights = { ...DEFAULT_WEIGHTS, ...config.weights };
+    this.decayRate = config.decayRate ?? DEFAULT_DECAY_RATE;
+  }
+  async initialize() {
+    await this.storage.initialize();
+  }
+  close() {
+    this.storage.close();
+  }
+  // ── Memory ──
+  async addMemory(input) {
+    const now = nowISO();
+    const layer = input.layer ?? "long_term";
+    const memory = {
+      id: generateId(),
+      content: input.content,
+      layer,
+      type: input.type ?? "note",
+      priority: MEMORY_LAYER_PRIORITY[layer] ?? 1,
+      importance: input.importance ?? 0.5,
+      tags: input.tags,
+      embedding: await this.embedding.embed(input.content),
+      expiresAt: input.expiresAt,
+      lastAccessedAt: now,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.storage.addMemory(memory);
+    return memory;
+  }
+  async searchMemories(query) {
+    const limit = query.limit ?? 10;
+    const weights = { ...this.weights, ...query.weights };
+    const queryEmbedding = query.embedding ?? await this.embedding.embed(query.text);
+    const semanticResults = await this.storage.searchMemories(queryEmbedding, limit * 2);
+    let bm25Results = [];
+    try {
+      bm25Results = await this.storage.fullTextSearch(query.text, limit * 2);
+    } catch {
+    }
+    const candidateMap = /* @__PURE__ */ new Map();
+    for (const { memory } of semanticResults)
+      candidateMap.set(memory.id, memory);
+    for (const { memory } of bm25Results)
+      candidateMap.set(memory.id, memory);
+    const semanticScoreMap = /* @__PURE__ */ new Map();
+    for (const { memory, distance } of semanticResults) {
+      semanticScoreMap.set(memory.id, distanceToSimilarity(distance));
+    }
+    const bm25ScoreMap = /* @__PURE__ */ new Map();
+    for (const { memory, rank } of bm25Results) {
+      bm25ScoreMap.set(memory.id, normalizeBm25(rank));
+    }
+    const layerFilter = query.layers ? new Set(query.layers) : null;
+    const results = [];
+    for (const [id, memory] of candidateMap) {
+      if (layerFilter && !layerFilter.has(memory.layer))
+        continue;
+      if (memory.expiresAt && new Date(memory.expiresAt) < /* @__PURE__ */ new Date())
+        continue;
+      const semantic = semanticScoreMap.get(id) ?? 0;
+      const bm25 = bm25ScoreMap.get(id) ?? 0;
+      const rec = recencyScore(memory.lastAccessedAt);
+      const sal = decay(memory.importance, memory.lastAccessedAt, this.decayRate);
+      const score = hybridScore(semantic, bm25, rec, sal, weights);
+      results.push({
+        id: memory.id,
+        type: "memory",
+        content: memory.content,
+        score,
+        scoreBreakdown: { semantic, bm25, recency: rec, salience: sal }
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  async updateMemory(id, input) {
+    await this.storage.updateMemory(id, input);
+    if (input.content !== void 0) {
+      const newEmbedding = await this.embedding.embed(input.content);
+      await this.storage.updateMemoryEmbedding(id, newEmbedding);
+    }
+  }
+  async deleteMemory(id) {
+    await this.storage.deleteMemory(id);
+  }
+  async getMemory(id) {
+    return this.storage.getMemory(id);
+  }
+  // ── Deduplication & Consolidation ──
+  async findDuplicates(memoryId, threshold = 0.3) {
+    const target = await this.storage.getMemory(memoryId);
+    if (!target)
+      throw new Error(`Memory not found: ${memoryId}`);
+    const embedding = target.embedding ?? await this.embedding.embed(target.content);
+    const similar = await this.storage.findSimilarMemories(embedding, threshold, 20);
+    return similar.filter((r) => r.memory.id !== memoryId);
+  }
+  async consolidateMemories(sourceIds, mergedContent, layer) {
+    const merged = await this.addMemory({
+      content: mergedContent,
+      layer: layer ?? "long_term",
+      type: "note"
+    });
+    for (const id of sourceIds) {
+      await this.storage.deleteMemory(id);
+    }
+    return merged;
+  }
+  // ── Graph ──
+  async addEntity(input) {
+    const now = nowISO();
+    const node = {
+      id: generateId(),
+      name: input.name,
+      nameEmbedding: await this.embedding.embed(input.name),
+      summary: input.summary,
+      entityType: input.entityType,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.storage.upsertNode(node);
+    return node;
+  }
+  async addEdge(input) {
+    const now = nowISO();
+    const edge = {
+      id: generateId(),
+      sourceId: input.sourceId,
+      targetId: input.targetId,
+      relation: input.relation,
+      fact: input.fact,
+      factEmbedding: input.fact ? await this.embedding.embed(input.fact) : void 0,
+      createdAt: now,
+      validAt: input.validAt
+    };
+    await this.storage.upsertEdge(edge);
+    return edge;
+  }
+  async getEdge(id) {
+    return this.storage.getEdge(id);
+  }
+  async invalidateEdge(edgeId) {
+    const now = nowISO();
+    await this.storage.invalidateEdge(edgeId, now, now);
+  }
+  async updateEdge(edgeId, input) {
+    const old = await this.storage.getEdge(edgeId);
+    if (!old)
+      return null;
+    const now = nowISO();
+    await this.storage.invalidateEdge(edgeId, now, now);
+    return this.addEdge({
+      sourceId: old.sourceId,
+      targetId: old.targetId,
+      relation: input.relation ?? old.relation,
+      fact: input.fact ?? old.fact,
+      validAt: now
+    });
+  }
+  async searchGraph(query, limit = 10, options) {
+    const depth = options?.traverseDepth ?? 1;
+    const queryEmbedding = await this.embedding.embed(query);
+    const nodes = await this.storage.searchNodes(queryEmbedding, Math.ceil(limit / 2));
+    const edges = await this.storage.searchEdges(queryEmbedding, { excludeExpired: true }, Math.ceil(limit / 2));
+    const results = [];
+    const seenNodeIds = /* @__PURE__ */ new Set();
+    for (const node of nodes) {
+      seenNodeIds.add(node.id);
+      results.push({
+        id: node.id,
+        type: "node",
+        content: `${node.name}${node.summary ? ": " + node.summary : ""}`,
+        score: 1
+      });
+    }
+    if (depth > 0) {
+      for (const node of nodes) {
+        const neighbors = await this.storage.getNeighbors(node.id, depth);
+        for (const neighbor of neighbors) {
+          if (!seenNodeIds.has(neighbor.id)) {
+            seenNodeIds.add(neighbor.id);
+            results.push({
+              id: neighbor.id,
+              type: "node",
+              content: `${neighbor.name}${neighbor.summary ? ": " + neighbor.summary : ""}`,
+              score: 0.5
+            });
+          }
+        }
+      }
+    }
+    for (const edge of edges) {
+      results.push({
+        id: edge.id,
+        type: "edge",
+        content: `${edge.relation}: ${edge.fact ?? ""}`,
+        score: 0.8
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  // ── Episodes ──
+  async addEpisode(input, refs) {
+    const episode = {
+      id: generateId(),
+      content: input.content,
+      contentType: input.contentType,
+      source: input.source,
+      createdAt: nowISO()
+    };
+    await this.storage.addEpisode(episode);
+    if (refs) {
+      for (const ref of refs) {
+        await this.storage.addEpisodeRef({ ...ref, episodeId: episode.id });
+      }
+    }
+    return episode;
+  }
+  async getEpisode(id) {
+    return this.storage.getEpisode(id);
+  }
+  async listEpisodes(limit = 20) {
+    return this.storage.listEpisodes(limit);
+  }
+  // ── Sessions ──
+  async sessionStart(metadata) {
+    const session = {
+      id: generateId(),
+      status: "active",
+      startedAt: nowISO(),
+      checkpointCount: 0,
+      metadata
+    };
+    await this.storage.addSession(session);
+    return session;
+  }
+  async sessionEnd(id) {
+    await this.storage.updateSession(id, {
+      status: "ended",
+      endedAt: nowISO()
+    });
+  }
+  async sessionCheckpoint(id) {
+    const session = await this.storage.getSession(id);
+    if (!session)
+      throw new Error(`Session not found: ${id}`);
+    await this.storage.updateSession(id, {
+      checkpointCount: session.checkpointCount + 1
+    });
+  }
+  async sessionList(limit = 20) {
+    return this.storage.listSessions(limit);
+  }
+  // ── Context ──
+  async getContext(options) {
+    return getContext(this.storage, options);
+  }
+};
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/memory.ts
+import { z } from "zod";
+
+// src/helpers/tool-helpers.ts
+function formatMemory(memory) {
+  const parts = [
+    `[${memory.layer}/${memory.type}] ${memory.content}`,
+    memory.tags?.length ? `tags: ${memory.tags.join(", ")}` : null,
+    memory.expiresAt ? `expires: ${memory.expiresAt}` : null
+  ].filter(Boolean);
+  return parts.join("\n");
+}
+function formatNode(node) {
+  const parts = [
+    `[${node.entityType ?? "entity"}] ${node.name}`,
+    node.summary ? `summary: ${node.summary}` : null
+  ].filter(Boolean);
+  return parts.join("\n");
+}
+function formatSearchResults(results) {
+  if (results.length === 0) return "No results found";
+  return results.map((r, i) => `${i + 1}. [${r.type}] (score: ${r.score.toFixed(3)}) ${r.content}`).join("\n");
+}
+function formatEpisode(episode) {
+  const parts = [
+    `[${episode.contentType ?? "text"}] ${episode.content.slice(0, 200)}`,
+    episode.source ? `source: ${episode.source}` : null,
+    `created: ${episode.createdAt}`
+  ].filter(Boolean);
+  return parts.join("\n");
+}
+function formatSession(session) {
+  return `[${session.status}] ${session.id} (started: ${session.startedAt}${session.endedAt ? `, ended: ${session.endedAt}` : ""}, checkpoints: ${session.checkpointCount})`;
+}
+function formatContext(ctx) {
+  const header = `Memories: ${ctx.memories.length}${ctx.truncated ? ` (of ${ctx.totalCount} total)` : ""}`;
+  const body = ctx.memories.map((m) => formatMemory(m)).join("\n---\n");
+  return `${header}
+
+${body}`;
+}
+function textContent(text) {
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/memory.ts
+function registerMemoryTools(server2, engine2) {
+  server2.tool(
+    "add_memory",
+    "Add a memory entry",
+    {
+      content: z.string().describe("Memory content"),
+      layer: z.enum(["rule", "working", "long_term"]).default("long_term").describe("Memory layer"),
+      type: z.enum(["rule", "decision", "fact", "note", "skill"]).default("note").describe("Memory type"),
+      tags: z.array(z.string()).optional().describe("Tags"),
+      expiresAt: z.string().optional().describe("Expiration date (ISO 8601)")
+    },
+    async (params) => {
+      const memory = await engine2.addMemory(params);
+      return textContent(`Memory added:
+${formatMemory(memory)}
+ID: ${memory.id}`);
+    }
+  );
+  server2.tool(
+    "search_memories",
+    "Search memories (semantic + BM25 hybrid search)",
+    {
+      query: z.string().describe("Search query"),
+      limit: z.number().int().min(1).max(100).default(10).describe("Max results"),
+      layers: z.array(z.enum(["rule", "working", "long_term"])).optional().describe("Target layers")
+    },
+    async (params) => {
+      const results = await engine2.searchMemories({
+        text: params.query,
+        limit: params.limit,
+        layers: params.layers
+      });
+      return textContent(formatSearchResults(results));
+    }
+  );
+  server2.tool(
+    "find_duplicates",
+    "Find duplicate candidates similar to a given memory",
+    {
+      memoryId: z.string().describe("Target memory ID"),
+      threshold: z.number().min(0).max(2).default(0.3).describe("Similarity threshold (distance, lower = more similar)")
+    },
+    async (params) => {
+      const duplicates = await engine2.findDuplicates(params.memoryId, params.threshold);
+      if (duplicates.length === 0) return textContent("No duplicates found");
+      const lines = duplicates.map(
+        (d, i) => `${i + 1}. (distance: ${d.distance.toFixed(3)}) ${formatMemory(d.memory)}
+   ID: ${d.memory.id}`
+      );
+      return textContent(`${duplicates.length} duplicate(s) found:
+${lines.join("\n")}`);
+    }
+  );
+  server2.tool(
+    "consolidate_memories",
+    "Consolidate multiple memories into one (source memories are soft-deleted)",
+    {
+      sourceIds: z.array(z.string()).min(2).describe("List of source memory IDs to merge"),
+      mergedContent: z.string().describe("Merged content text"),
+      layer: z.enum(["rule", "working", "long_term"]).optional().describe("Target layer for merged memory")
+    },
+    async (params) => {
+      const merged = await engine2.consolidateMemories(params.sourceIds, params.mergedContent, params.layer);
+      return textContent(`Consolidated ${params.sourceIds.length} memories:
+${formatMemory(merged)}
+ID: ${merged.id}`);
+    }
+  );
+  server2.tool(
+    "update_memory",
+    "Update a memory entry",
+    {
+      id: z.string().describe("Memory ID"),
+      content: z.string().optional().describe("New content"),
+      layer: z.enum(["rule", "working", "long_term"]).optional().describe("New layer"),
+      type: z.enum(["rule", "decision", "fact", "note", "skill"]).optional().describe("New type"),
+      importance: z.number().min(0).max(1).optional().describe("Importance (0-1)"),
+      tags: z.array(z.string()).optional().describe("New tags")
+    },
+    async (params) => {
+      const { id, ...input } = params;
+      await engine2.updateMemory(id, input);
+      return textContent(`Memory ${id} updated`);
+    }
+  );
+  server2.tool(
+    "delete_memory",
+    "Delete a memory (soft delete)",
+    {
+      id: z.string().describe("Memory ID")
+    },
+    async (params) => {
+      await engine2.deleteMemory(params.id);
+      return textContent(`Memory ${params.id} deleted`);
+    }
+  );
+}
+
+// src/tools/session.ts
+import { z as z2 } from "zod";
+function registerSessionTools(server2, engine2) {
+  server2.tool(
+    "session_start",
+    "Start a new session",
+    {
+      metadata: z2.string().optional().describe("Session metadata (JSON)")
+    },
+    async (params) => {
+      const session = await engine2.sessionStart(params.metadata);
+      return textContent(`Session started:
+${formatSession(session)}`);
+    }
+  );
+  server2.tool(
+    "session_end",
+    "End a session",
+    {
+      id: z2.string().describe("Session ID")
+    },
+    async (params) => {
+      await engine2.sessionEnd(params.id);
+      return textContent(`Session ${params.id} ended`);
+    }
+  );
+  server2.tool(
+    "session_checkpoint",
+    "Create a session checkpoint",
+    {
+      id: z2.string().describe("Session ID")
+    },
+    async (params) => {
+      await engine2.sessionCheckpoint(params.id);
+      return textContent(`Checkpoint created for session ${params.id}`);
+    }
+  );
+  server2.tool(
+    "session_list",
+    "List past sessions",
+    {
+      limit: z2.number().int().min(1).max(100).default(20).describe("Max results")
+    },
+    async (params) => {
+      const sessions = await engine2.sessionList(params.limit);
+      if (sessions.length === 0) return textContent("No sessions found");
+      return textContent(sessions.map((s) => formatSession(s)).join("\n"));
+    }
+  );
+}
+
+// src/tools/context.ts
+import { z as z3 } from "zod";
+function registerContextTools(server2, engine2) {
+  server2.tool(
+    "get_context",
+    "Get current context (priority: rule > working > long_term)",
+    {
+      maxMemories: z3.number().int().min(1).max(200).default(50).describe("Max number of memories")
+    },
+    async (params) => {
+      const ctx = await engine2.getContext({ maxMemories: params.maxMemories });
+      return textContent(formatContext(ctx));
+    }
+  );
+}
+
+// src/tools/graph.ts
+import { z as z4 } from "zod";
+function registerGraphTools(server2, engine2) {
+  server2.tool(
+    "add_entity",
+    "Add an entity to the knowledge graph",
+    {
+      name: z4.string().describe("Entity name"),
+      summary: z4.string().optional().describe("Summary"),
+      entityType: z4.string().optional().describe("Type (person, project, technology, etc.)")
+    },
+    async (params) => {
+      const node = await engine2.addEntity(params);
+      return textContent(`Entity added:
+${formatNode(node)}
+ID: ${node.id}`);
+    }
+  );
+  server2.tool(
+    "add_edge",
+    "Add an edge (relationship) to the knowledge graph",
+    {
+      sourceId: z4.string().describe("Source node ID"),
+      targetId: z4.string().describe("Target node ID"),
+      relation: z4.string().describe("Relation (works_at, uses, depends_on, etc.)"),
+      fact: z4.string().optional().describe("Fact description"),
+      validAt: z4.string().optional().describe("Valid-from timestamp (ISO 8601)")
+    },
+    async (params) => {
+      const edge = await engine2.addEdge(params);
+      return textContent(`Edge added: ${edge.sourceId} --[${edge.relation}]--> ${edge.targetId}
+ID: ${edge.id}`);
+    }
+  );
+  server2.tool(
+    "invalidate_edge",
+    "Invalidate an edge (mark as expired while preserving history)",
+    {
+      id: z4.string().describe("Edge ID to invalidate")
+    },
+    async (params) => {
+      await engine2.invalidateEdge(params.id);
+      return textContent(`Edge ${params.id} invalidated`);
+    }
+  );
+  server2.tool(
+    "update_edge",
+    "Update an edge fact (invalidates old, creates new with history preserved)",
+    {
+      id: z4.string().describe("Edge ID to update"),
+      relation: z4.string().optional().describe("New relation"),
+      fact: z4.string().optional().describe("New fact")
+    },
+    async (params) => {
+      const edge = await engine2.updateEdge(params.id, {
+        relation: params.relation,
+        fact: params.fact
+      });
+      if (!edge) return textContent(`Edge ${params.id} not found`);
+      return textContent(`Edge updated: ${edge.sourceId} --[${edge.relation}]--> ${edge.targetId}
+New ID: ${edge.id}`);
+    }
+  );
+  server2.tool(
+    "search_graph",
+    "Search the knowledge graph (semantic search + graph traversal)",
+    {
+      query: z4.string().describe("Search query"),
+      limit: z4.number().int().min(1).max(100).default(10).describe("Max results"),
+      traverseDepth: z4.number().int().min(0).max(2).default(1).describe("Graph traversal depth (0=none, 1=1-hop, 2=2-hop)")
+    },
+    async (params) => {
+      const results = await engine2.searchGraph(params.query, params.limit, {
+        traverseDepth: params.traverseDepth
+      });
+      return textContent(formatSearchResults(results));
+    }
+  );
+}
+
+// src/tools/episode.ts
+import { z as z5 } from "zod";
+function registerEpisodeTools(server2, engine2) {
+  server2.tool(
+    "add_episode",
+    "Add an episode (conversation log or action record)",
+    {
+      content: z5.string().describe("Episode content"),
+      contentType: z5.enum(["text", "json", "message"]).default("text").describe("Content format"),
+      source: z5.string().optional().describe("Source info (session_id, file_path, etc.)"),
+      refs: z5.array(z5.object({
+        refType: z5.enum(["node", "edge"]).describe("Reference type"),
+        refId: z5.string().describe("Referenced entity ID")
+      })).optional().describe("References to related nodes/edges")
+    },
+    async (params) => {
+      const refs = params.refs?.map((r) => ({
+        episodeId: "",
+        // set inside addEpisode
+        refType: r.refType,
+        refId: r.refId
+      }));
+      const episode = await engine2.addEpisode(
+        { content: params.content, contentType: params.contentType, source: params.source },
+        refs
+      );
+      return textContent(`Episode added:
+${formatEpisode(episode)}
+ID: ${episode.id}`);
+    }
+  );
+  server2.tool(
+    "get_episode",
+    "Get an episode by ID",
+    {
+      id: z5.string().describe("Episode ID")
+    },
+    async (params) => {
+      const episode = await engine2.getEpisode(params.id);
+      if (!episode) return textContent(`Episode ${params.id} not found`);
+      return textContent(formatEpisode(episode));
+    }
+  );
+  server2.tool(
+    "list_episodes",
+    "List episodes",
+    {
+      limit: z5.number().int().min(1).max(100).default(20).describe("Max results")
+    },
+    async (params) => {
+      const episodes = await engine2.listEpisodes(params.limit);
+      if (episodes.length === 0) return textContent("No episodes found");
+      const lines = episodes.map((ep, i) => `${i + 1}. ${formatEpisode(ep)}
+   ID: ${ep.id}`);
+      return textContent(`${episodes.length} episode(s):
+${lines.join("\n")}`);
+    }
+  );
+}
+
+// src/tools/generate.ts
+import { z as z6 } from "zod";
+var GENERATORS = [
+  { toolName: "generate_claude_md", description: "Generate a CLAUDE.md file", fileName: "CLAUDE.md", format: "claude_md" },
+  { toolName: "generate_cursorrules", description: "Generate a .cursorrules file", fileName: ".cursorrules", format: "cursorrules" },
+  { toolName: "generate_windsurf", description: "Generate a Windsurf config file", fileName: ".windsurfrules", format: "windsurf" },
+  { toolName: "generate_copilot", description: "Generate a GitHub Copilot config", fileName: ".github/copilot-instructions.md", format: "copilot" },
+  { toolName: "generate_codex", description: "Generate a Codex config", fileName: "codex.md", format: "codex" },
+  { toolName: "generate_aider", description: "Generate an Aider config", fileName: ".aider.conf.yml", format: "aider" },
+  { toolName: "generate_continue", description: "Generate a Continue config", fileName: ".continue/rules.md", format: "continue" },
+  { toolName: "generate_cline", description: "Generate a Cline config", fileName: ".clinerules", format: "cline" },
+  { toolName: "generate_roo", description: "Generate a Roo Code config", fileName: ".roo/rules.md", format: "roo" }
+];
+async function generateContent(engine2, format) {
+  const ctx = await engine2.getContext({ maxMemories: 100 });
+  const rules = ctx.memories.filter((m) => m.layer === "rule");
+  const longTerm = ctx.memories.filter((m) => m.layer === "long_term");
+  const sections = [];
+  if (rules.length > 0) {
+    sections.push("# Rules\n");
+    for (const m of rules) {
+      sections.push(`- ${m.content}`);
+    }
+    sections.push("");
+  }
+  if (longTerm.length > 0) {
+    sections.push("# Project Knowledge\n");
+    for (const m of longTerm) {
+      sections.push(`- ${m.content}`);
+    }
+    sections.push("");
+  }
+  const content = sections.join("\n");
+  switch (format) {
+    case "claude_md":
+    case "cursorrules":
+    case "windsurf":
+    case "copilot":
+    case "codex":
+    case "continue":
+    case "cline":
+    case "roo":
+      return content;
+    case "aider":
+      return `# Aider Configuration
+# Generated by cohaku-ai
+
+read:
+  - .aiderrules
+`;
+    default:
+      return content;
+  }
+}
+function registerGenerateTools(server2, engine2) {
+  for (const gen of GENERATORS) {
+    const { format } = gen;
+    server2.tool(
+      gen.toolName,
+      gen.description,
+      {
+        includeWorking: z6.boolean().default(false).describe("Include working memory")
+      },
+      async () => {
+        const content = await generateContent(engine2, format);
+        return textContent(`# ${gen.fileName}
+
+${content}
+
+---
+Save the above content to ${gen.fileName}.`);
+      }
+    );
+  }
+}
+
+// src/server.ts
+function createServer(engine2) {
+  const server2 = new McpServer({
+    name: "cohaku-memory",
+    version: "0.1.0"
+  });
+  registerContextTools(server2, engine2);
+  registerMemoryTools(server2, engine2);
+  registerSessionTools(server2, engine2);
+  registerGraphTools(server2, engine2);
+  registerEpisodeTools(server2, engine2);
+  registerGenerateTools(server2, engine2);
+  return server2;
+}
+
+// src/index.ts
+var dbPath = process.env["COHAKU_DB_PATH"] ?? join(homedir(), ".config", "cohaku", "memory.db");
+var engine = new MemoryEngine({ dbPath });
+await engine.initialize();
+var server = createServer(engine);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+process.on("SIGINT", () => {
+  engine.close();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  engine.close();
+  process.exit(0);
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@cohaku/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Cohaku persistent memory layer",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cohaku-ai/cohaku-ai"
+  },
+  "keywords": [
+    "mcp",
+    "memory",
+    "ai",
+    "coding-agent",
+    "knowledge-graph",
+    "model-context-protocol"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "cohaku-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@xenova/transformers": "^2.17.2",
+    "better-sqlite3": "^12.6.2",
+    "nanoid": "^5.1.6",
+    "sqlite-vec": "0.1.7-alpha.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@cohaku/core": "workspace:*",
+    "@cohaku/shared": "workspace:*",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.3.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  }
+}