@cohaku/mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { join } from "path";
+import { join, basename } from "path";
 import { homedir } from "os";
+import { execSync } from "child_process";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // ../core/dist/storage/sqlite-driver.js
@@ -25,11 +26,12 @@ var DEFAULT_DECAY_RATE = 0.01;
 var DEFAULT_EMBEDDING_DIMENSIONS = 384;
 
 // ../core/dist/storage/schema.js
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 2;
 var CREATE_TABLES = `
   -- Memory (3-layer)
   CREATE TABLE IF NOT EXISTS memories (
     id TEXT PRIMARY KEY,
+    project_id TEXT,
     content TEXT NOT NULL,
     layer TEXT NOT NULL DEFAULT 'long_term',
     type TEXT NOT NULL DEFAULT 'note',
@@ -73,6 +75,7 @@ var CREATE_TABLES = `
   -- Entity nodes
   CREATE TABLE IF NOT EXISTS nodes (
     id TEXT PRIMARY KEY,
+    project_id TEXT,
     name TEXT NOT NULL,
     name_embedding BLOB,
     summary TEXT,
@@ -84,6 +87,7 @@ var CREATE_TABLES = `
   -- Edges (bi-temporal)
   CREATE TABLE IF NOT EXISTS edges (
     id TEXT PRIMARY KEY,
+    project_id TEXT,
     source_id TEXT NOT NULL REFERENCES nodes(id),
     target_id TEXT NOT NULL REFERENCES nodes(id),
     relation TEXT NOT NULL,
@@ -98,6 +102,7 @@ var CREATE_TABLES = `
   -- Episodes
   CREATE TABLE IF NOT EXISTS episodes (
     id TEXT PRIMARY KEY,
+    project_id TEXT,
     content TEXT NOT NULL,
     content_type TEXT,
     source TEXT,
@@ -115,6 +120,7 @@ var CREATE_TABLES = `
   -- Sessions
   CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
+    project_id TEXT,
     status TEXT NOT NULL DEFAULT 'active',
     started_at TEXT NOT NULL,
     ended_at TEXT,
@@ -132,10 +138,28 @@ var CREATE_TABLES = `
   -- 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_memories_project ON memories(project_id);
+  CREATE INDEX IF NOT EXISTS idx_nodes_project ON nodes(project_id);
   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_edges_project ON edges(project_id);
+  CREATE INDEX IF NOT EXISTS idx_episodes_project ON episodes(project_id);
   CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+`;
+var MIGRATE_V1_TO_V2 = `
+  ALTER TABLE memories ADD COLUMN project_id TEXT;
+  ALTER TABLE nodes ADD COLUMN project_id TEXT;
+  ALTER TABLE edges ADD COLUMN project_id TEXT;
+  ALTER TABLE episodes ADD COLUMN project_id TEXT;
+  ALTER TABLE sessions ADD COLUMN project_id TEXT;
+
+  CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+  CREATE INDEX IF NOT EXISTS idx_nodes_project ON nodes(project_id);
+  CREATE INDEX IF NOT EXISTS idx_edges_project ON edges(project_id);
+  CREATE INDEX IF NOT EXISTS idx_episodes_project ON episodes(project_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
 `;
 function createVecTables(dimensions) {
   return `
@@ -178,27 +202,51 @@ var SqliteDriver = class {
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
     sqliteVec.load(this.db);
+    this.db.exec("CREATE TABLE IF NOT EXISTS config (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+    const existing = this.db.prepare("SELECT value FROM config WHERE key = ?").get("schema_version");
+    const currentVersion = existing ? Number(existing.value) : 0;
+    if (currentVersion >= 1 && currentVersion < 2) {
+      for (const stmt of MIGRATE_V1_TO_V2.split(";").filter((s) => s.trim())) {
+        this.db.exec(stmt);
+      }
+    }
     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));
-    }
+    this.db.prepare("INSERT INTO config (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run("schema_version", String(SCHEMA_VERSION));
   }
   close() {
     this.db.close();
   }
+  // ── Project Filter Helper ──
+  buildProjectFilter(projectIds, tableAlias) {
+    if (!projectIds)
+      return { clause: "", params: [] };
+    const hasNull = projectIds.includes(null);
+    const nonNull = projectIds.filter((id) => id !== null);
+    const conditions = [];
+    const params = [];
+    if (hasNull) {
+      conditions.push(`${tableAlias}.project_id IS NULL`);
+    }
+    if (nonNull.length > 0) {
+      conditions.push(`${tableAlias}.project_id IN (${nonNull.map(() => "?").join(", ")})`);
+      params.push(...nonNull);
+    }
+    if (conditions.length === 0)
+      return { clause: "", params: [] };
+    return { clause: `AND (${conditions.join(" OR ")})`, params };
+  }
   // ── 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);
+        INSERT INTO memories (id, project_id, content, layer, type, priority, importance, tags, expires_at, last_accessed_at, created_at, updated_at, deleted_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(memory.id, memory.projectId ?? null, 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 (?, ?)
@@ -249,7 +297,8 @@ var SqliteDriver = class {
   async deleteMemory(id) {
     this.db.prepare("UPDATE memories SET deleted_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
   }
-  async searchMemories(embedding, limit) {
+  async searchMemories(embedding, limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "m");
     const rows = this.db.prepare(`
       SELECT m.*, v.distance
       FROM vec_memories v
@@ -257,55 +306,60 @@ var SqliteDriver = class {
       WHERE v.embedding MATCH ?
         AND m.deleted_at IS NULL
         AND k = ?
-    `).all(toVecBlob(embedding), limit);
+        ${clause}
+    `).all(toVecBlob(embedding), limit, ...params);
     return rows.map((row) => ({
       memory: this.rowToMemory(row),
       distance: row.distance
     }));
   }
-  async fullTextSearch(query, limit) {
+  async fullTextSearch(query, limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "m");
     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
+        ${clause}
       ORDER BY fts.rank
       LIMIT ?
-    `).all(query, limit);
+    `).all(query, ...params, 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);
+  async findSimilarMemories(embedding, threshold, limit, projectIds) {
+    const results = await this.searchMemories(embedding, limit * 3, projectIds);
     return results.filter((r) => r.distance <= threshold).slice(0, limit);
   }
-  async listMemoriesByLayer(layer, limit) {
+  async listMemoriesByLayer(layer, limit, projectIds) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const { clause, params } = this.buildProjectFilter(projectIds, "memories");
     const rows = this.db.prepare(`
       SELECT * FROM memories
       WHERE layer = ?
         AND deleted_at IS NULL
         AND (expires_at IS NULL OR expires_at > ?)
+        ${clause}
       ORDER BY updated_at DESC
       LIMIT ?
-    `).all(layer, now, limit);
+    `).all(layer, now, ...params, 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 (?, ?, ?, ?, ?, ?)
+        INSERT INTO nodes (id, project_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);
+      `).run(node.id, node.projectId ?? null, 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 = ?
@@ -320,29 +374,31 @@ var SqliteDriver = class {
     const row = this.db.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
     return row ? this.rowToNode(row) : null;
   }
-  async searchNodes(embedding, limit) {
+  async searchNodes(embedding, limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "n");
     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);
+        ${clause}
+    `).all(toVecBlob(embedding), limit, ...params);
     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 (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO edges (id, project_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);
+      `).run(edge.id, edge.projectId ?? null, 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 = ?
@@ -360,7 +416,7 @@ var SqliteDriver = class {
   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) {
+  async searchEdges(embedding, filters, limit, projectIds) {
     let whereClause = "1=1";
     const params = [toVecBlob(embedding), limit];
     if (filters.excludeExpired !== false) {
@@ -372,6 +428,9 @@ var SqliteDriver = class {
       whereClause += " AND (e.invalid_at IS NULL OR e.invalid_at > ?)";
       params.push(filters.asOf);
     }
+    const { clause: projectClause, params: projectParams } = this.buildProjectFilter(projectIds, "e");
+    whereClause += ` ${projectClause}`;
+    params.push(...projectParams);
     const rows = this.db.prepare(`
       SELECT e.*
       FROM vec_edges v
@@ -427,9 +486,9 @@ var SqliteDriver = class {
   // ── 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);
+      INSERT INTO episodes (id, project_id, content, content_type, source, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(episode.id, episode.projectId ?? null, episode.content, episode.contentType ?? null, episode.source ?? null, episode.createdAt);
   }
   async addEpisodeRef(ref) {
     this.db.prepare(`
@@ -441,8 +500,9 @@ var SqliteDriver = class {
     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);
+  async listEpisodes(limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "episodes");
+    const rows = this.db.prepare(`SELECT * FROM episodes WHERE 1=1 ${clause} ORDER BY created_at DESC LIMIT ?`).all(...params, limit);
     return rows.map((row) => this.rowToEpisode(row));
   }
   async getEpisodeRefs(episodeId) {
@@ -456,9 +516,9 @@ var SqliteDriver = class {
   // ── 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);
+      INSERT INTO sessions (id, project_id, status, started_at, ended_at, checkpoint_count, working_memory_snapshot, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(session.id, session.projectId ?? null, session.status, session.startedAt, session.endedAt ?? null, session.checkpointCount, session.workingMemorySnapshot ?? null, session.metadata ?? null);
   }
   async updateSession(id, updates) {
     const sets = [];
@@ -492,8 +552,9 @@ var SqliteDriver = class {
     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);
+  async listSessions(limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "sessions");
+    const rows = this.db.prepare(`SELECT * FROM sessions WHERE 1=1 ${clause} ORDER BY started_at DESC LIMIT ?`).all(...params, limit);
     return rows.map((row) => this.rowToSession(row));
   }
   // ── Config ──
@@ -508,6 +569,7 @@ var SqliteDriver = class {
   rowToMemory(row) {
     return {
       id: row.id,
+      projectId: row.project_id ?? void 0,
       content: row.content,
       layer: row.layer,
       type: row.type,
@@ -524,6 +586,7 @@ var SqliteDriver = class {
   rowToNode(row) {
     return {
       id: row.id,
+      projectId: row.project_id ?? void 0,
       name: row.name,
       summary: row.summary ?? void 0,
       entityType: row.entity_type ?? void 0,
@@ -534,6 +597,7 @@ var SqliteDriver = class {
   rowToEdge(row) {
     return {
       id: row.id,
+      projectId: row.project_id ?? void 0,
       sourceId: row.source_id,
       targetId: row.target_id,
       relation: row.relation,
@@ -547,6 +611,7 @@ var SqliteDriver = class {
   rowToEpisode(row) {
     return {
       id: row.id,
+      projectId: row.project_id ?? void 0,
       content: row.content,
       contentType: row.content_type ?? void 0,
       source: row.source ?? void 0,
@@ -556,6 +621,7 @@ var SqliteDriver = class {
   rowToSession(row) {
     return {
       id: row.id,
+      projectId: row.project_id ?? void 0,
       status: row.status,
       startedAt: row.started_at,
       endedAt: row.ended_at ?? void 0,
@@ -632,12 +698,12 @@ function distanceToSimilarity(distance) {
 
 // ../core/dist/engine/context.js
 async function getContext(storage, options = {}) {
-  const { maxMemories = 50 } = options;
-  const rules = await storage.listMemoriesByLayer("rule", maxMemories);
+  const { maxMemories = 50, projectIds } = options;
+  const rules = await storage.listMemoriesByLayer("rule", maxMemories, projectIds);
   const remaining1 = maxMemories - rules.length;
-  const working = remaining1 > 0 ? await storage.listMemoriesByLayer("working", Math.ceil(remaining1 * 0.6)) : [];
+  const working = remaining1 > 0 ? await storage.listMemoriesByLayer("working", Math.ceil(remaining1 * 0.6), projectIds) : [];
   const remaining2 = maxMemories - rules.length - working.length;
-  const longTerm = remaining2 > 0 ? await storage.listMemoriesByLayer("long_term", remaining2) : [];
+  const longTerm = remaining2 > 0 ? await storage.listMemoriesByLayer("long_term", remaining2, projectIds) : [];
   const memories = [...rules, ...working, ...longTerm];
   const totalCount = memories.length;
   return {
@@ -653,12 +719,14 @@ var MemoryEngine = class {
   embedding;
   weights;
   decayRate;
+  defaultProjectId;
   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;
+    this.defaultProjectId = config.defaultProjectId;
   }
   async initialize() {
     await this.storage.initialize();
@@ -666,12 +734,28 @@ var MemoryEngine = class {
   close() {
     this.storage.close();
   }
+  // ── Scope Helpers ──
+  resolveProjectId(scope) {
+    if (scope === "global")
+      return void 0;
+    return this.defaultProjectId;
+  }
+  resolveProjectFilter(scope) {
+    if (scope === "all")
+      return void 0;
+    if (scope === "global")
+      return [null];
+    if (this.defaultProjectId)
+      return [this.defaultProjectId, null];
+    return void 0;
+  }
   // ── Memory ──
   async addMemory(input) {
     const now = nowISO();
     const layer = input.layer ?? "long_term";
     const memory = {
       id: generateId(),
+      projectId: this.resolveProjectId(input.scope),
       content: input.content,
       layer,
       type: input.type ?? "note",
@@ -690,11 +774,12 @@ var MemoryEngine = class {
   async searchMemories(query) {
     const limit = query.limit ?? 10;
     const weights = { ...this.weights, ...query.weights };
+    const projectIds = this.resolveProjectFilter(query.scope);
     const queryEmbedding = query.embedding ?? await this.embedding.embed(query.text);
-    const semanticResults = await this.storage.searchMemories(queryEmbedding, limit * 2);
+    const semanticResults = await this.storage.searchMemories(queryEmbedding, limit * 2, projectIds);
     let bm25Results = [];
     try {
-      bm25Results = await this.storage.fullTextSearch(query.text, limit * 2);
+      bm25Results = await this.storage.fullTextSearch(query.text, limit * 2, projectIds);
     } catch {
     }
     const candidateMap = /* @__PURE__ */ new Map();
@@ -752,7 +837,8 @@ var MemoryEngine = class {
     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);
+    const projectIds = this.resolveProjectFilter("project");
+    const similar = await this.storage.findSimilarMemories(embedding, threshold, 20, projectIds);
     return similar.filter((r) => r.memory.id !== memoryId);
   }
   async consolidateMemories(sourceIds, mergedContent, layer) {
@@ -771,6 +857,7 @@ var MemoryEngine = class {
     const now = nowISO();
     const node = {
       id: generateId(),
+      projectId: this.resolveProjectId(input.scope),
       name: input.name,
       nameEmbedding: await this.embedding.embed(input.name),
       summary: input.summary,
@@ -785,6 +872,7 @@ var MemoryEngine = class {
     const now = nowISO();
     const edge = {
       id: generateId(),
+      projectId: this.resolveProjectId(input.scope),
       sourceId: input.sourceId,
       targetId: input.targetId,
       relation: input.relation,
@@ -819,9 +907,10 @@ var MemoryEngine = class {
   }
   async searchGraph(query, limit = 10, options) {
     const depth = options?.traverseDepth ?? 1;
+    const projectIds = this.resolveProjectFilter(options?.scope);
     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 nodes = await this.storage.searchNodes(queryEmbedding, Math.ceil(limit / 2), projectIds);
+    const edges = await this.storage.searchEdges(queryEmbedding, { excludeExpired: true }, Math.ceil(limit / 2), projectIds);
     const results = [];
     const seenNodeIds = /* @__PURE__ */ new Set();
     for (const node of nodes) {
@@ -864,6 +953,7 @@ var MemoryEngine = class {
   async addEpisode(input, refs) {
     const episode = {
       id: generateId(),
+      projectId: this.resolveProjectId(input.scope),
       content: input.content,
       contentType: input.contentType,
       source: input.source,
@@ -880,13 +970,15 @@ var MemoryEngine = class {
   async getEpisode(id) {
     return this.storage.getEpisode(id);
   }
-  async listEpisodes(limit = 20) {
-    return this.storage.listEpisodes(limit);
+  async listEpisodes(limit = 20, scope) {
+    const projectIds = this.resolveProjectFilter(scope);
+    return this.storage.listEpisodes(limit, projectIds);
   }
   // ── Sessions ──
   async sessionStart(metadata) {
     const session = {
       id: generateId(),
+      projectId: this.resolveProjectId("project"),
       status: "active",
       startedAt: nowISO(),
       checkpointCount: 0,
@@ -909,12 +1001,14 @@ var MemoryEngine = class {
       checkpointCount: session.checkpointCount + 1
     });
   }
-  async sessionList(limit = 20) {
-    return this.storage.listSessions(limit);
+  async sessionList(limit = 20, scope) {
+    const projectIds = this.resolveProjectFilter(scope);
+    return this.storage.listSessions(limit, projectIds);
   }
   // ── Context ──
   async getContext(options) {
-    return getContext(this.storage, options);
+    const projectIds = this.resolveProjectFilter(options?.scope);
+    return getContext(this.storage, { ...options, projectIds });
   }
 };
 
@@ -967,6 +1061,8 @@ function textContent(text) {
 }
 
 // src/tools/memory.ts
+var scopeSchema = z.enum(["project", "global"]).default("project").describe('Scope: "project" (default) stores in current project, "global" stores across all projects');
+var searchScopeSchema = z.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
 function registerMemoryTools(server2, engine2) {
   server2.tool(
     "add_memory",
@@ -976,7 +1072,8 @@ function registerMemoryTools(server2, engine2) {
       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)")
+      expiresAt: z.string().optional().describe("Expiration date (ISO 8601)"),
+      scope: scopeSchema
     },
     async (params) => {
       const memory = await engine2.addMemory(params);
@@ -991,13 +1088,15 @@ ID: ${memory.id}`);
     {
       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")
+      layers: z.array(z.enum(["rule", "working", "long_term"])).optional().describe("Target layers"),
+      scope: searchScopeSchema
     },
     async (params) => {
       const results = await engine2.searchMemories({
         text: params.query,
         limit: params.limit,
-        layers: params.layers
+        layers: params.layers,
+        scope: params.scope
       });
       return textContent(formatSearchResults(results));
     }
@@ -1067,6 +1166,7 @@ ID: ${merged.id}`);
 
 // src/tools/session.ts
 import { z as z2 } from "zod";
+var searchScopeSchema2 = z2.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
 function registerSessionTools(server2, engine2) {
   server2.tool(
     "session_start",
@@ -1106,10 +1206,11 @@ ${formatSession(session)}`);
     "session_list",
     "List past sessions",
     {
-      limit: z2.number().int().min(1).max(100).default(20).describe("Max results")
+      limit: z2.number().int().min(1).max(100).default(20).describe("Max results"),
+      scope: searchScopeSchema2
     },
     async (params) => {
-      const sessions = await engine2.sessionList(params.limit);
+      const sessions = await engine2.sessionList(params.limit, params.scope);
       if (sessions.length === 0) return textContent("No sessions found");
       return textContent(sessions.map((s) => formatSession(s)).join("\n"));
     }
@@ -1118,15 +1219,17 @@ ${formatSession(session)}`);
 
 // src/tools/context.ts
 import { z as z3 } from "zod";
+var searchScopeSchema3 = z3.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
 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")
+      maxMemories: z3.number().int().min(1).max(200).default(50).describe("Max number of memories"),
+      scope: searchScopeSchema3
     },
     async (params) => {
-      const ctx = await engine2.getContext({ maxMemories: params.maxMemories });
+      const ctx = await engine2.getContext({ maxMemories: params.maxMemories, scope: params.scope });
       return textContent(formatContext(ctx));
     }
   );
@@ -1134,6 +1237,8 @@ function registerContextTools(server2, engine2) {
 
 // src/tools/graph.ts
 import { z as z4 } from "zod";
+var scopeSchema2 = z4.enum(["project", "global"]).default("project").describe('Scope: "project" (default) stores in current project, "global" stores across all projects');
+var searchScopeSchema4 = z4.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
 function registerGraphTools(server2, engine2) {
   server2.tool(
     "add_entity",
@@ -1141,7 +1246,8 @@ function registerGraphTools(server2, engine2) {
     {
       name: z4.string().describe("Entity name"),
       summary: z4.string().optional().describe("Summary"),
-      entityType: z4.string().optional().describe("Type (person, project, technology, etc.)")
+      entityType: z4.string().optional().describe("Type (person, project, technology, etc.)"),
+      scope: scopeSchema2
     },
     async (params) => {
       const node = await engine2.addEntity(params);
@@ -1158,7 +1264,8 @@ ID: ${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)")
+      validAt: z4.string().optional().describe("Valid-from timestamp (ISO 8601)"),
+      scope: scopeSchema2
     },
     async (params) => {
       const edge = await engine2.addEdge(params);
@@ -1201,11 +1308,13 @@ New ID: ${edge.id}`);
     {
       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)")
+      traverseDepth: z4.number().int().min(0).max(2).default(1).describe("Graph traversal depth (0=none, 1=1-hop, 2=2-hop)"),
+      scope: searchScopeSchema4
     },
     async (params) => {
       const results = await engine2.searchGraph(params.query, params.limit, {
-        traverseDepth: params.traverseDepth
+        traverseDepth: params.traverseDepth,
+        scope: params.scope
       });
       return textContent(formatSearchResults(results));
     }
@@ -1214,6 +1323,8 @@ New ID: ${edge.id}`);
 
 // src/tools/episode.ts
 import { z as z5 } from "zod";
+var scopeSchema3 = z5.enum(["project", "global"]).default("project").describe('Scope: "project" (default) stores in current project, "global" stores across all projects');
+var searchScopeSchema5 = z5.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
 function registerEpisodeTools(server2, engine2) {
   server2.tool(
     "add_episode",
@@ -1225,7 +1336,8 @@ function registerEpisodeTools(server2, engine2) {
       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")
+      })).optional().describe("References to related nodes/edges"),
+      scope: scopeSchema3
     },
     async (params) => {
       const refs = params.refs?.map((r) => ({
@@ -1235,7 +1347,7 @@ function registerEpisodeTools(server2, engine2) {
         refId: r.refId
       }));
       const episode = await engine2.addEpisode(
-        { content: params.content, contentType: params.contentType, source: params.source },
+        { content: params.content, contentType: params.contentType, source: params.source, scope: params.scope },
         refs
       );
       return textContent(`Episode added:
@@ -1259,10 +1371,11 @@ ID: ${episode.id}`);
     "list_episodes",
     "List episodes",
     {
-      limit: z5.number().int().min(1).max(100).default(20).describe("Max results")
+      limit: z5.number().int().min(1).max(100).default(20).describe("Max results"),
+      scope: searchScopeSchema5
     },
     async (params) => {
-      const episodes = await engine2.listEpisodes(params.limit);
+      const episodes = await engine2.listEpisodes(params.limit, params.scope);
       if (episodes.length === 0) return textContent("No episodes found");
       const lines = episodes.map((ep, i) => `${i + 1}. ${formatEpisode(ep)}
    ID: ${ep.id}`);
@@ -1364,11 +1477,72 @@ function createServer(engine2) {
 }
 
 // src/index.ts
+var VERSION = "0.2.0";
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  amber: "\x1B[38;5;214m",
+  yellow: "\x1B[38;5;220m",
+  gray: "\x1B[38;5;245m",
+  green: "\x1B[38;5;114m",
+  white: "\x1B[97m"
+};
 var dbPath = process.env["COHAKU_DB_PATH"] ?? join(homedir(), ".config", "cohaku", "memory.db");
-var engine = new MemoryEngine({ dbPath });
+function detectProjectId() {
+  const envProjectId = process.env["COHAKU_PROJECT_ID"];
+  if (envProjectId) return envProjectId;
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return gitRoot || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function checkForUpdate() {
+  try {
+    const res = await fetch("https://registry.npmjs.org/@cohaku/mcp/latest", {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (data.version && data.version !== VERSION) return data.version;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function printBanner(projectId, latestVersion2) {
+  const projectName = projectId ? basename(projectId) : void 0;
+  const scopeLabel = projectName ? `${c.green}${projectName}${c.reset}` : `${c.gray}global${c.reset}`;
+  const lines = [
+    "",
+    `  ${c.amber}${c.bold}\u25C6 Cohaku AI${c.reset} ${c.dim}v${VERSION}${c.reset}`
+  ];
+  if (latestVersion2) {
+    lines.push(`  ${c.yellow}\u26A0 v${latestVersion2} available${c.reset} ${c.dim}\u2014 npx @cohaku/mcp@latest${c.reset}`);
+  }
+  lines.push(
+    "",
+    `  ${c.gray}Scope${c.reset}     ${scopeLabel}`,
+    `  ${c.gray}Database${c.reset}  ${c.dim}${dbPath.replace(homedir(), "~")}${c.reset}`,
+    `  ${c.gray}Transport${c.reset} ${c.dim}stdio${c.reset}`,
+    "",
+    `  ${c.green}\u25CF${c.reset} ${c.white}Ready${c.reset} ${c.dim}\u2014 waiting for MCP client${c.reset}`,
+    ""
+  );
+  process.stderr.write(lines.join("\n") + "\n");
+}
+var defaultProjectId = detectProjectId();
+var engine = new MemoryEngine({ dbPath, defaultProjectId });
 await engine.initialize();
 var server = createServer(engine);
 var transport = new StdioServerTransport();
+var latestVersion = await checkForUpdate();
+printBanner(defaultProjectId, latestVersion);
 await server.connect(transport);
 process.on("SIGINT", () => {
   engine.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohaku/mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "MCP server for Cohaku persistent memory layer",
   "type": "module",
   "license": "MIT",