@codemem/mcp 0.44.0 → 0.44.2

package/dist/server-DmdZAo6k.js

@@ -0,0 +1,1157 @@
+import { createHash as e, randomUUID as t } from "node:crypto";
+import { MEMORY_KIND_DESCRIPTIONS as n, ObserverClient as r, REMEMBER_MEMORY_KINDS as i, VERSION as a, buildDistillReport as o, dedupeOrderedIds as s, judgeDistillReport as c, projectMatchesFilter as l, reconcileFailedRetrievalSurface as u, recordRetrievalSurface as d, resolveProject as f, resolveProjectRoot as p, storeVectors as m, toJson as h } from "@codemem/core";
+import { existsSync as g, readFileSync as ee } from "node:fs";
+import { homedir as te } from "node:os";
+import { join as _ } from "node:path";
+import { McpServer as ne } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as v } from "zod";
+//#region src/canonical-json.ts
+function y(e) {
+	return JSON.stringify(e, (e, t) => typeof t != "object" || !t || Array.isArray(t) ? t : Object.fromEntries(Object.entries(t).toSorted(([e], [t]) => e < t ? -1 : +(e > t)))) ?? "undefined";
+}
+//#endregion
+//#region src/project-scope.ts
+function b(e) {
+	return e?.trim() || null;
+}
+function x() {
+	return b(process.env.CODEMEM_PROJECT) ?? f(process.cwd());
+}
+function re(e) {
+	return b(e.project) ?? b(e.envProject) ?? null;
+}
+function S(e, t = x()) {
+	let n = {}, r = !1, i = (typeof e.project == "string" ? b(e.project) : void 0) || b(t) || void 0;
+	i && (n.project = i, r = !0);
+	for (let t of [
+		"kind",
+		"visibility",
+		"scope_id",
+		"include_scope_ids",
+		"exclude_scope_ids",
+		"include_visibility",
+		"exclude_visibility",
+		"include_workspace_ids",
+		"exclude_workspace_ids",
+		"include_workspace_kinds",
+		"exclude_workspace_kinds",
+		"include_actor_ids",
+		"exclude_actor_ids",
+		"include_trust_states",
+		"exclude_trust_states",
+		"ownership_scope",
+		"personal_first",
+		"trust_bias",
+		"widen_shared_when_weak",
+		"widen_shared_min_personal_results",
+		"widen_shared_min_personal_score"
+	]) {
+		let i = e[t];
+		i != null && (n[t] = i, r = !0);
+	}
+	return r ? n : void 0;
+}
+//#endregion
+//#region src/content.ts
+function ie(e) {
+	let t = JSON.parse(e);
+	if (!t || typeof t != "object" || Array.isArray(t)) throw TypeError("MCP structured content must be a JSON object");
+	return t;
+}
+function C(e) {
+	let t = JSON.stringify(e);
+	if (t === void 0) throw TypeError("MCP structured content must be JSON serializable");
+	return {
+		content: [{
+			type: "text",
+			text: t
+		}],
+		structuredContent: ie(t)
+	};
+}
+function w(e) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify({ error: e })
+		}],
+		isError: !0
+	};
+}
+//#endregion
+//#region src/schemas.ts
+var T = {
+	scope_id: v.string().optional().describe("Filter by a single sharing domain scope_id"),
+	include_scope_ids: v.array(v.string()).optional().describe("Sharing domain scope_ids to include"),
+	exclude_scope_ids: v.array(v.string()).optional().describe("Sharing domain scope_ids to exclude")
+}, E = {
+	kind: v.string().optional().describe("Filter by memory kind"),
+	project: v.string().optional().describe("Filter by project scope (matches sessions.project)"),
+	...T,
+	visibility: v.array(v.string()).optional(),
+	include_visibility: v.array(v.string()).optional(),
+	exclude_visibility: v.array(v.string()).optional(),
+	include_workspace_ids: v.array(v.string()).optional(),
+	exclude_workspace_ids: v.array(v.string()).optional(),
+	include_workspace_kinds: v.array(v.string()).optional(),
+	exclude_workspace_kinds: v.array(v.string()).optional(),
+	include_actor_ids: v.array(v.string()).optional(),
+	exclude_actor_ids: v.array(v.string()).optional(),
+	include_trust_states: v.array(v.string()).optional(),
+	exclude_trust_states: v.array(v.string()).optional(),
+	ownership_scope: v.string().optional(),
+	personal_first: v.union([v.boolean(), v.string()]).optional(),
+	trust_bias: v.string().optional(),
+	widen_shared_when_weak: v.union([v.boolean(), v.string()]).optional(),
+	widen_shared_min_personal_results: v.number().int().optional(),
+	widen_shared_min_personal_score: v.number().optional()
+}, ae = v.enum(i), oe = Object.keys(E).toSorted(), D = v.record(v.string(), v.unknown()), O = v.number().nullable(), k = v.object({
+	id: v.number().int(),
+	kind: v.string(),
+	title: v.string(),
+	body_text: v.string(),
+	session_id: v.number().int().optional(),
+	confidence: O.optional(),
+	created_at: v.string().optional(),
+	updated_at: v.string().optional(),
+	metadata_json: D.optional()
+}).passthrough(), se = v.object({
+	id: v.number().int(),
+	kind: v.string(),
+	title: v.string(),
+	body: v.string(),
+	confidence: O.optional(),
+	score: v.number().optional(),
+	session_id: v.number().int().optional(),
+	metadata: D.optional()
+}).passthrough(), ce = v.object({
+	id: v.number().int(),
+	kind: v.string(),
+	title: v.string(),
+	score: v.number(),
+	created_at: v.string(),
+	session_id: v.number().int(),
+	metadata: D
+}).passthrough(), A = v.object({
+	code: v.string(),
+	field: v.string(),
+	message: v.string(),
+	ids: v.array(v.union([v.string(), v.number()])).optional()
+}).passthrough(), le = v.object({
+	id: v.number().int(),
+	kind: v.string(),
+	title: v.string(),
+	created_at: v.string(),
+	project: v.string().nullable(),
+	retrieval: v.object({
+		source: v.string(),
+		rank: v.number().int().nullable()
+	}).passthrough(),
+	score: v.object({
+		total: v.number().nullable(),
+		components: v.object({
+			base: v.number().nullable(),
+			recency: v.number(),
+			kind_bonus: v.number(),
+			personal_bias: v.number(),
+			semantic_boost: v.number().nullable()
+		}).passthrough()
+	}).passthrough(),
+	role: v.object({
+		inferred: v.string(),
+		reason: v.string()
+	}).passthrough(),
+	matches: v.object({
+		query_terms: v.array(v.string()),
+		project_match: v.boolean().nullable()
+	}).passthrough(),
+	pack_context: v.object({
+		included: v.boolean().nullable(),
+		section: v.string().nullable()
+	}).passthrough().nullable()
+}).passthrough(), ue = v.object({
+	id: v.number().int(),
+	kind: v.string(),
+	title: v.string(),
+	body: v.string(),
+	confidence: O,
+	metadata: D
+}).passthrough(), j = v.object({
+	when: v.array(v.string()),
+	how: v.array(v.string()),
+	examples: v.array(v.string())
+}).passthrough(), M = {
+	memory_search: v.object({ items: v.array(se) }),
+	memory_search_index: v.object({ items: v.array(ce) }),
+	memory_explain: v.object({
+		items: v.array(le),
+		missing_ids: v.array(v.number().int()),
+		errors: v.array(A),
+		metadata: v.object({
+			query: v.string().nullable(),
+			project: v.string().nullable(),
+			requested_ids_count: v.number().int(),
+			returned_items_count: v.number().int(),
+			include_pack_context: v.boolean(),
+			sanitized_query: v.string().optional()
+		}).passthrough()
+	}),
+	memory_recent: v.object({ items: v.array(k) }),
+	memory_pack: v.object({
+		context: v.string(),
+		items: v.array(ue),
+		item_ids: v.array(v.number().int()),
+		pack_text: v.string(),
+		metrics: v.object({
+			total_items: v.number().int(),
+			pack_tokens: v.number().int(),
+			fallback_used: v.boolean(),
+			limit: v.number().int(),
+			project: v.string().nullable(),
+			pack_item_ids: v.array(v.number().int())
+		}).passthrough()
+	}),
+	memory_timeline: v.object({ items: v.array(k) }),
+	memory_expand: v.object({
+		anchors: v.array(k),
+		timeline: v.array(k),
+		observations: v.array(k),
+		missing_ids: v.array(v.number().int()),
+		errors: v.array(A),
+		metadata: v.object({
+			project: v.string().nullable(),
+			requested_ids_count: v.number().int(),
+			returned_anchor_count: v.number().int(),
+			timeline_count: v.number().int(),
+			include_observations: v.boolean()
+		}).passthrough()
+	}),
+	memory_get: k,
+	memory_get_observations: v.object({ items: v.array(k) }),
+	memory_remember: v.object({ id: v.number().int() }),
+	memory_forget: v.object({ status: v.literal("ok") }),
+	memory_distill_candidates: v.object({
+		version: v.literal(1),
+		candidates: v.array(v.object({
+			scope: v.enum(["project", "user"]),
+			suggested_target: v.string().nullable(),
+			score: v.number(),
+			recurrence: v.number().int(),
+			projects: v.array(v.string()),
+			member_ids: v.array(v.number().int()),
+			representative_id: v.number().int(),
+			concepts: v.array(v.string()),
+			artifact_kind: v.enum(["context_fact", "skill"]),
+			evidence: v.array(v.string()),
+			draft_text: v.string().nullable()
+		}).passthrough()),
+		metadata: v.object({
+			candidate_count: v.number().int(),
+			cluster_count: v.number().int(),
+			context_document_count: v.number().int(),
+			corpus_count: v.number().int(),
+			corpus_limit: v.number().int(),
+			documented_cluster_count: v.number().int(),
+			include_documented: v.boolean(),
+			min_recurrence: v.number().int()
+		}).passthrough()
+	}),
+	memory_schema: v.object({
+		kinds: v.array(v.string()),
+		kind_descriptions: v.record(v.string(), v.string()),
+		fields: v.record(v.string(), v.string()),
+		filters: v.array(v.string())
+	}),
+	memory_learn: v.object({
+		intro: v.string(),
+		client_hint: v.string(),
+		recall: j,
+		persistence: j,
+		forget: j,
+		prompt_hint: v.string(),
+		recommended_system_prompt: v.string()
+	})
+}, N = {
+	readOnlyHint: !0,
+	openWorldHint: !1
+}, P = {
+	readOnlyHint: !0,
+	openWorldHint: !0
+}, F = {
+	memory_search: N,
+	memory_search_index: N,
+	memory_explain: N,
+	memory_recent: N,
+	memory_pack: P,
+	memory_timeline: N,
+	memory_expand: N,
+	memory_get: N,
+	memory_get_observations: N,
+	memory_remember: {
+		readOnlyHint: !1,
+		destructiveHint: !1,
+		idempotentHint: !1,
+		openWorldHint: !0
+	},
+	memory_forget: {
+		readOnlyHint: !1,
+		destructiveHint: !0,
+		idempotentHint: !0,
+		openWorldHint: !1
+	},
+	memory_distill_candidates: P,
+	memory_schema: N,
+	memory_learn: N
+}, de = {
+	limit: v.number().int().min(1).max(50).default(10).describe("Max candidates"),
+	min_recurrence: v.number().int().min(1).max(50).default(2).describe("Minimum member count per candidate"),
+	all_projects: v.boolean().default(!1).describe("Mine memories across all projects"),
+	include_documented: v.boolean().default(!1).describe("Include candidates already represented in context files"),
+	max_evidence_items: v.number().int().min(1).max(20).default(5).describe("Evidence snippets per candidate"),
+	judge: v.boolean().default(!0).describe("Judge candidates with the observer model and drop routine-activity clusters (on by default; falls back to unjudged output when no observer model is configured)"),
+	...E
+};
+function I(e, t, n) {
+	if (!g(e)) return null;
+	let r = ee(e, "utf8");
+	return r.trim() ? {
+		path: t,
+		text: r,
+		scope: n
+	} : null;
+}
+function L(e, t = process.cwd()) {
+	let n = p(t) ?? t;
+	return [e ? I(_(n, "AGENTS.md"), "AGENTS.md", "project") : null, I(_(te(), ".config", "opencode", "AGENTS.md"), "~/.config/opencode/AGENTS.md", "user")].filter((e) => e != null);
+}
+function R(e, t) {
+	if (e.all_projects) return !1;
+	let n = f(process.cwd());
+	if (!n) return !1;
+	let r = typeof e.project == "string" ? e.project.trim() : "", i = r ? f(process.cwd(), r) : t;
+	return i ? l(i, n) : !1;
+}
+function z(e, t) {
+	if (e.all_projects && typeof e.project == "string" && e.project.trim()) throw Error("project cannot be combined with all_projects");
+	return S(e, e.all_projects ? null : t);
+}
+function B(e, t) {
+	let { defaultProject: n, store: i } = t;
+	e.registerTool("memory_distill_candidates", {
+		description: "Mine recurring memories into reviewable context candidates. Reads project/user context files without modifying them and can call the optional observer when judge=true.",
+		inputSchema: de,
+		outputSchema: M.memory_distill_candidates,
+		annotations: F.memory_distill_candidates
+	}, async (e) => {
+		try {
+			let t = n(), a = z(e, t), s = e.kind ? [e.kind] : void 0, l = e.judge ? Math.min(e.limit * 3, e.limit + 20) : e.limit, u = await o(i, {
+				candidate: {
+					includeDocumented: e.include_documented,
+					maxEvidenceItems: e.max_evidence_items
+				},
+				contextDocuments: L(R(e, t)),
+				corpus: {
+					filters: a ?? null,
+					kinds: s
+				},
+				limit: l,
+				minRecurrence: e.min_recurrence
+			});
+			if (e.judge) {
+				try {
+					let e = new r();
+					u = await c(u, async (t, n) => (await e.observe(t, n)).raw);
+				} catch (e) {
+					let t = e instanceof Error ? e.message : String(e);
+					u = {
+						...u,
+						metadata: {
+							...u.metadata,
+							judged: !1,
+							judge_error: t
+						}
+					};
+				}
+				u.candidates.length > e.limit && (u = {
+					...u,
+					candidates: u.candidates.slice(0, e.limit),
+					metadata: {
+						...u.metadata,
+						candidate_count: e.limit
+					}
+				});
+			}
+			return C(u);
+		} catch (e) {
+			return w(e instanceof Error ? e.message : String(e));
+		}
+	});
+}
+//#endregion
+//#region src/mcp-retrieval-ledger.ts
+var V = 3e5, H = 2e3, U = /* @__PURE__ */ new WeakMap(), W = 0;
+function G(e, t, n) {
+	if (e.captureRetrievalLedger) try {
+		let r = d(e.store.db, t);
+		n && !r.ok && r.reason === "idempotency_conflict" && (t.retrievalStatus === "succeeded" && t.deliveryStatus === "handed_off" || t.retrievalStatus === "no_results" && t.deliveryStatus === "not_attempted") && u(e.store.db, t);
+	} catch {}
+}
+function K(e) {
+	if (e == null) return t();
+	let n = e.slice(0, 32).split("");
+	n[12] = "5", n[16] = (Number.parseInt(n[16] ?? "0", 16) & 3 | 8).toString(16);
+	let r = n.join("");
+	return `${r.slice(0, 8)}-${r.slice(8, 12)}-${r.slice(12, 16)}-${r.slice(16, 20)}-${r.slice(20)}`;
+}
+function fe(t, n) {
+	if (n.requestId == null) return null;
+	let r = e("sha256").update(y({
+		method: "tools/call",
+		params: {
+			name: n.toolName,
+			arguments: n.toolArguments
+		}
+	})).digest("hex");
+	return e("sha256").update(JSON.stringify([
+		n.sourceSessionId ?? t.retrievalLedgerScopeId,
+		n.requestId,
+		r
+	])).digest("hex");
+}
+function q(e) {
+	let t = U.get(e);
+	return t || (t = {
+		byInvocation: /* @__PURE__ */ new WeakMap(),
+		activeByRequest: /* @__PURE__ */ new Map(),
+		pendingFailures: /* @__PURE__ */ new Map(),
+		pendingFailureCount: 0,
+		nextPendingFailureOrder: 0,
+		nextInvocationSequence: 0
+	}, U.set(e, t)), t;
+}
+function J(e, t) {
+	for (let [n, r] of e.pendingFailures) {
+		let i = r.filter((e) => e.expiresAt > t);
+		e.pendingFailureCount -= r.length - i.length, i.length === 0 ? e.pendingFailures.delete(n) : i.length !== r.length && e.pendingFailures.set(n, i);
+	}
+	for (; e.pendingFailureCount > H;) {
+		let t, n = Infinity;
+		for (let [r, i] of e.pendingFailures) {
+			let e = i[0]?.order;
+			e != null && e < n && (t = r, n = e);
+		}
+		if (t === void 0) break;
+		let r = e.pendingFailures.get(t), i = r?.shift();
+		if (!r || !i) {
+			e.pendingFailures.delete(t);
+			continue;
+		}
+		--e.pendingFailureCount, r.length === 0 && e.pendingFailures.delete(t);
+	}
+}
+function Y(e, t) {
+	let n = e.pendingFailures.get(t);
+	if (!n) return;
+	let r = n.shift();
+	if (r) return --e.pendingFailureCount, n.length === 0 && e.pendingFailures.delete(t), r.identity;
+}
+function pe(e, t, n) {
+	let r = e.pendingFailures.get(t), i = r?.findIndex((e) => e.identity.attemptId === n) ?? -1;
+	!r || i < 0 || (r.splice(i, 1), --e.pendingFailureCount, r.length === 0 && e.pendingFailures.delete(t));
+}
+function me(e, t, n, r) {
+	let i = e.pendingFailures.get(t) ?? [];
+	i.some((e) => e.identity.attemptId === n.attemptId) || (i.push({
+		identity: n,
+		expiresAt: r + V,
+		order: e.nextPendingFailureOrder
+	}), e.nextPendingFailureOrder += 1, e.pendingFailures.set(t, i), e.pendingFailureCount += 1, J(e, r));
+}
+function he() {
+	try {
+		return {
+			baseRequestId: null,
+			requestId: null,
+			attemptId: t()
+		};
+	} catch {
+		let e = Date.now().toString(16).slice(-8).padStart(8, "0"), t = W.toString(16).slice(-4).padStart(4, "0");
+		return W = (W + 1) % 65536, {
+			baseRequestId: null,
+			requestId: null,
+			attemptId: `00000000-0000-4000-8000-${e}${t}`
+		};
+	}
+}
+function ge(t, n) {
+	let r = fe(t, n);
+	if (t.retrievalLedgerIdentityMode === "stateless" || r == null) return {
+		baseRequestId: r,
+		requestId: r,
+		attemptId: K(r)
+	};
+	let i = q(t);
+	J(i, Date.now());
+	let a = n.invocationIdentity ? i.byInvocation.get(n.invocationIdentity) : void 0, o = a?.baseRequestId === r ? a : void 0;
+	if (!o) {
+		let a = (i.activeByRequest.get(r) ?? 0) === 0 ? Y(i, r) : void 0;
+		if (a) o = a;
+		else {
+			let n = i.nextInvocationSequence;
+			i.nextInvocationSequence += 1;
+			let a = e("sha256").update(JSON.stringify([
+				r,
+				t.retrievalLedgerScopeId,
+				n
+			])).digest("hex");
+			o = {
+				baseRequestId: r,
+				requestId: a,
+				attemptId: K(a)
+			};
+		}
+		n.invocationIdentity && i.byInvocation.set(n.invocationIdentity, o);
+	}
+	return i.activeByRequest.set(r, (i.activeByRequest.get(r) ?? 0) + 1), o;
+}
+function _e(e, t) {
+	try {
+		return ge(e, t);
+	} catch {
+		return he();
+	}
+}
+function ve(e, t, n) {
+	if (e.retrievalLedgerIdentityMode === "stateless" || t.baseRequestId == null) return;
+	let r = q(e), i = r.activeByRequest.get(t.baseRequestId) ?? 0;
+	i <= 1 ? r.activeByRequest.delete(t.baseRequestId) : r.activeByRequest.set(t.baseRequestId, i - 1), n === "failed" ? me(r, t.baseRequestId, t, Date.now()) : pe(r, t.baseRequestId, t.attemptId);
+}
+function X(e, t, n) {
+	try {
+		ve(e, t, n);
+	} catch {}
+}
+async function Z(e, t, n) {
+	let r = _e(e, t), i = r.requestId, a = r.attemptId, o = /* @__PURE__ */ new Date(), s;
+	try {
+		s = t.resolveFilters?.();
+		let c = await n(s), l = /* @__PURE__ */ new Date(), u = c.error ? w(c.error) : C(c.value), d = t.sourceSessionId ?? e.retrievalLedgerScopeId, f = c.memoryIds.length > 0, p = c.error === "not_found" && !f, m = c.error != null && !p || c.retrievalStatus === "failed" && !f, h = m ? [] : c.memoryIds, g = c.retrievalStatus === "unknown" ? "unknown" : "succeeded";
+		return G(e, {
+			attemptId: a,
+			surface: t.surface,
+			trigger: "explicit",
+			startedAt: o.toISOString(),
+			completedAt: l.toISOString(),
+			retrievalStatus: m ? "failed" : f ? g : "no_results",
+			deliveryStatus: m || !f ? "not_attempted" : "handed_off",
+			candidateIds: h,
+			selectedIds: h,
+			candidateCount: f && !m ? c.candidateCount : 0,
+			recorderVersion: "mcp-retrieval-v1",
+			source: "mcp",
+			streamId: d,
+			sourceSessionId: t.sourceSessionId ?? null,
+			requestId: i,
+			latencyMs: Math.max(0, l.getTime() - o.getTime()),
+			filters: c.filters ?? s,
+			query: t.query,
+			limitRequested: t.limit,
+			failureCode: m ? "tool_failed" : void 0,
+			failureStage: m ? "retrieval" : void 0
+		}, !m), X(e, r, m ? "failed" : "completed"), u;
+	} catch (n) {
+		let c = /* @__PURE__ */ new Date(), l = t.sourceSessionId ?? e.retrievalLedgerScopeId;
+		return G(e, {
+			attemptId: a,
+			surface: t.surface,
+			trigger: "explicit",
+			startedAt: o.toISOString(),
+			completedAt: c.toISOString(),
+			retrievalStatus: "failed",
+			deliveryStatus: "not_attempted",
+			candidateIds: [],
+			selectedIds: [],
+			recorderVersion: "mcp-retrieval-v1",
+			source: "mcp",
+			streamId: l,
+			sourceSessionId: t.sourceSessionId ?? null,
+			requestId: i,
+			latencyMs: Math.max(0, c.getTime() - o.getTime()),
+			query: t.query,
+			limitRequested: t.limit,
+			filters: s,
+			failureCode: "tool_failed",
+			failureStage: "retrieval"
+		}, !1), X(e, r, "failed"), w(n instanceof Error ? n.message : String(n));
+	}
+}
+//#endregion
+//#region src/memory-access.ts
+function Q(e, t, n) {
+	return e.timeline(null, t, 0, 0, n ?? null).find((e) => e.id === t) ?? null;
+}
+function $(e, t, n) {
+	if (t.length === 0) return [];
+	let r = [];
+	for (let i of t) {
+		let t = Q(e, i, n);
+		t && r.push(t);
+	}
+	return r;
+}
+function ye(e, t, n) {
+	return Q(e, t, n) ? (e.forget(t), !0) : !1;
+}
+function be(e, t, n = {}) {
+	return e.db.transaction(() => {
+		let r = n.now?.() ?? (/* @__PURE__ */ new Date()).toISOString(), i = n.user ?? process.env.USER ?? "unknown", a = n.cwd ?? process.cwd(), o = re({
+			project: t.project,
+			envProject: n.envProject
+		}), s = e.db.prepare("INSERT INTO sessions(started_at, ended_at, cwd, project, user, tool_version, metadata_json)\n				 VALUES (?, ?, ?, ?, ?, ?, ?)").run(r, r, a, o, i, "mcp-ts", h({ mcp: !0 })), c = Number(s.lastInsertRowid), l = e.remember(c, t.kind, t.title, t.body, t.confidence);
+		if (!Q(e, l)) throw Error("unauthorized_scope");
+		return e.db.prepare("UPDATE sessions SET ended_at = ?, metadata_json = ? WHERE id = ?").run(n.now?.() ?? (/* @__PURE__ */ new Date()).toISOString(), h({ mcp: !0 }), c), {
+			memId: l,
+			title: t.title,
+			body: t.body
+		};
+	})();
+}
+//#endregion
+//#region src/tools/items.ts
+var xe = {
+	memory_id: v.number().int().describe("Memory ID"),
+	...E
+}, Se = {
+	ids: v.array(v.number().int()).max(200).describe("Memory IDs to fetch"),
+	...E
+}, Ce = {
+	kind: ae.describe("Memory kind"),
+	title: v.string().describe("Short title"),
+	body: v.string().describe("Body text (high-signal content)"),
+	confidence: v.number().min(0).max(1).default(.5).describe("Confidence 0-1"),
+	project: v.string().optional().describe("Project identifier")
+}, we = {
+	memory_id: v.number().int().describe("Memory ID to forget"),
+	...E
+};
+function Te(e, t) {
+	e.registerTool("memory_get", {
+		description: "Fetch one memory by exact ID. Does not inherit the default project; optional filters constrain the lookup, and a mismatch returns not_found.",
+		inputSchema: xe,
+		outputSchema: M.memory_get,
+		annotations: F.memory_get
+	}, async (e, n) => Z(t, {
+		surface: "mcp_get",
+		toolName: "memory_get",
+		toolArguments: e,
+		limit: 1,
+		resolveFilters: () => S(e, null),
+		requestId: n?.requestId,
+		sourceSessionId: n?.sessionId,
+		invocationIdentity: n?.signal
+	}, (n) => {
+		let r = Q(t.store, e.memory_id, n);
+		return r ? {
+			value: r,
+			memoryIds: [r.id],
+			filters: n
+		} : {
+			value: null,
+			memoryIds: [],
+			error: "not_found",
+			filters: n
+		};
+	}));
+}
+function Ee(e, t) {
+	e.registerTool("memory_get_observations", {
+		description: "Fetch multiple memories by exact IDs. Does not inherit the default project. Missing or filtered-out IDs are omitted from results, not reported as not_found.",
+		inputSchema: Se,
+		outputSchema: M.memory_get_observations,
+		annotations: F.memory_get_observations
+	}, async (e, n) => Z(t, {
+		surface: "mcp_get_observations",
+		toolName: "memory_get_observations",
+		toolArguments: e,
+		limit: e.ids.length,
+		resolveFilters: () => S(e, null),
+		requestId: n?.requestId,
+		sourceSessionId: n?.sessionId,
+		invocationIdentity: n?.signal
+	}, (n) => {
+		let r = $(t.store, e.ids, n);
+		return {
+			value: { items: r },
+			memoryIds: r.map((e) => e.id),
+			filters: n
+		};
+	}));
+}
+function De(e, t) {
+	e.registerTool("memory_remember", {
+		description: "Create a new memory. Use for milestones, decisions, and notable facts.",
+		inputSchema: Ce,
+		outputSchema: M.memory_remember,
+		annotations: F.memory_remember
+	}, async (e) => {
+		try {
+			let n = be(t.store, e, { envProject: t.envProject() });
+			try {
+				await m(t.store.db, n.memId, n.title, n.body);
+			} catch {}
+			return C({ id: n.memId });
+		} catch (e) {
+			return w(e instanceof Error ? e.message : String(e));
+		}
+	});
+}
+function Oe(e, t) {
+	e.registerTool("memory_forget", {
+		description: "Soft-delete a memory by exact ID so it no longer appears in normal retrieval; this is not secure erasure. Does not inherit the default project; optional filters must match or the tool returns not_found.",
+		inputSchema: we,
+		outputSchema: M.memory_forget,
+		annotations: F.memory_forget
+	}, async (e) => {
+		try {
+			return ye(t.store, e.memory_id, S(e, null)) ? C({ status: "ok" }) : w("not_found");
+		} catch (e) {
+			return w(e instanceof Error ? e.message : String(e));
+		}
+	});
+}
+function ke(e, t) {
+	Te(e, t), Ee(e, t), De(e, t), Oe(e, t);
+}
+//#endregion
+//#region src/tools/learn.ts
+var Ae = {
+	intro: "Use this tool when you're new to codemem or unsure when to recall/persist.",
+	client_hint: "If you are unfamiliar with codemem, call memory_learn first.",
+	recall: {
+		when: ["Start of a task or when the user references prior work.", "When you need background context, decisions, or recent changes."],
+		how: [
+			"Use memory_search or memory_search_index for exact terms and identifiers; memory_search returns bodies, while memory_search_index returns compact candidates.",
+			"Use memory_pack for conceptually relevant context; it combines keyword and semantic search when embeddings are available and falls back to keyword search when they are not.",
+			"Use memory_timeline to expand around a promising memory.",
+			"Use memory_get or memory_get_observations for full details only when needed.",
+			"Use the project filter unless the user requests cross-project context.",
+			"Project, trust, and ownership filters organize and select memories; they are not authentication or tenant-isolation controls."
+		],
+		examples: [
+			"memory_search_index(query=\"billing cache bug\", limit=5)",
+			"memory_timeline(memory_id=123)",
+			"memory_get_observations(ids=[123, 456])"
+		]
+	},
+	persistence: {
+		when: ["Milestones (task done, key decision, new facts learned).", "Notable regressions or follow-ups that should be remembered."],
+		how: [
+			"Use memory_remember with kind decision/discovery/change/exploration.",
+			"Keep titles short and bodies high-signal.",
+			"ALWAYS pass the project parameter if known."
+		],
+		examples: ["memory_remember(kind=\"decision\", title=\"Switch to async cache\", body=\"...why...\", project=\"my-service\")", "memory_remember(kind=\"change\", title=\"Fixed retry loop\", body=\"...impact...\", project=\"my-service\")"]
+	},
+	forget: {
+		when: ["Obsolete or incorrect items that should no longer surface.", "Items that should be soft-deleted; soft deletion is not secure erasure."],
+		how: [
+			"Call memory_forget(memory_id) to mark the item inactive.",
+			"Optional filters constrain the exact-ID lookup; a filter mismatch returns not_found.",
+			"Do not treat memory_forget as secure erasure or a user-data erasure guarantee."
+		],
+		examples: ["memory_forget(memory_id=123)"]
+	},
+	prompt_hint: "At task start: call memory_search_index for exact terms or memory_pack for conceptual context; during work: memory_timeline + memory_get_observations; at milestones: memory_remember.",
+	recommended_system_prompt: [
+		"Trigger policy (1-liner): If the user references prior work or starts a task,",
+		"call memory_search_index for exact terms or memory_pack for conceptual context; then use",
+		"memory_timeline + memory_get_observations; at milestones, call memory_remember.",
+		"",
+		"System prompt:",
+		"You have access to codemem MCP tools. If unfamiliar, call memory_learn first.",
+		"",
+		"Recall:",
+		"- For exact terms or identifiers, use memory_search_index for compact candidates or memory_search for bodies.",
+		"- For conceptually relevant context, use memory_pack; it falls back to keyword search without embeddings.",
+		"- If prior work is referenced (\"as before\", \"last time\", \"we already did…\", \"regression\"),",
+		"  call memory_search_index, memory_pack, or memory_timeline as appropriate.",
+		"- Use memory_get or memory_get_observations only after filtering IDs.",
+		"- Prefer project-scoped queries unless the user asks for cross-project.",
+		"- Project, trust, and ownership filters select memories; they do not authenticate or isolate tenants.",
+		"",
+		"Persistence:",
+		"- On milestones (task done, key decision, new facts learned), call memory_remember.",
+		"- Use kind=decision for tradeoffs, kind=change for outcomes, kind=discovery/exploration for useful findings.",
+		"- Keep titles short and bodies high-signal.",
+		"- ALWAYS pass the project parameter if known.",
+		"",
+		"Safety:",
+		"- Use memory_forget(memory_id) to soft-delete incorrect or obsolete items; this is not secure erasure.",
+		"",
+		"Examples:",
+		"- memory_search_index(query=\"billing cache bug\")",
+		"- memory_timeline(memory_id=123)",
+		"- memory_get_observations(ids=[123, 456])",
+		"- memory_remember(kind=\"decision\", title=\"Use async cache\", body=\"Chose async cache to avoid lock contention in X.\", project=\"my-service\")",
+		"- memory_remember(kind=\"change\", title=\"Fixed retry loop\", body=\"Root cause was Y; added guard in Z.\", project=\"my-service\")",
+		"- memory_forget(memory_id=123)"
+	].join("\n")
+};
+function je(e) {
+	e.registerTool("memory_learn", {
+		description: "Learn how to use codemem memory tools. Call this first if unfamiliar.",
+		inputSchema: {},
+		outputSchema: M.memory_learn,
+		annotations: F.memory_learn
+	}, async () => C(Ae));
+}
+//#endregion
+//#region src/tools/schema.ts
+function Me(e) {
+	e.registerTool("memory_schema", {
+		description: "Return the memory schema — kinds, fields, and available filters.",
+		inputSchema: {},
+		outputSchema: M.memory_schema,
+		annotations: F.memory_schema
+	}, async () => C({
+		kinds: Object.keys(n),
+		kind_descriptions: n,
+		fields: {
+			title: "short text",
+			body: "long text",
+			subtitle: "short text",
+			facts: "list<string>",
+			narrative: "long text",
+			concepts: "list<string>",
+			files_read: "list<string>",
+			files_modified: "list<string>",
+			prompt_number: "int"
+		},
+		filters: oe
+	}));
+}
+//#endregion
+//#region src/tools/search.ts
+var Ne = {
+	query: v.string().describe("Search query"),
+	limit: v.number().int().min(1).max(50).default(5).describe("Max results"),
+	...E
+}, Pe = {
+	query: v.string().describe("Search query"),
+	limit: v.number().int().min(1).max(50).default(8).describe("Max results"),
+	...E
+}, Fe = {
+	query: v.string().optional().describe("Search query"),
+	ids: v.array(v.number().int()).max(200).optional().describe("Specific memory IDs to explain"),
+	limit: v.number().int().min(1).max(50).default(10).describe("Max results"),
+	include_pack_context: v.boolean().default(!1).describe("Include formatted pack context"),
+	...E
+}, Ie = {
+	limit: v.number().int().min(1).max(100).default(8).describe("Max results"),
+	...E
+}, Le = {
+	context: v.string().describe("Context description to search for"),
+	limit: v.number().int().min(1).max(50).optional().describe("Max items to include"),
+	compact: v.boolean().optional().describe("When true, render a scannable index of all items with full detail only for the top N (default 3). Saves tokens when broad overview matters more than per-item detail."),
+	compact_detail_count: v.number().int().min(0).max(50).optional().describe("Number of items to show in full detail in compact mode (default 3)"),
+	compression_mode: v.enum([
+		"off",
+		"compact",
+		"ids"
+	]).optional().describe("Near-related compression mode: off disables it, compact applies only to compact rendering, ids applies in all modes. Defaults to CODEMEM_PACK_COMPRESSION or compact."),
+	...E
+};
+function Re(e, t) {
+	let { defaultProject: n, store: r } = t;
+	e.registerTool("memory_search", {
+		description: "Keyword-search memories when you know exact terms or identifiers. Returns full body text for each match; use memory_search_index when you only need compact candidates.",
+		inputSchema: Ne,
+		outputSchema: M.memory_search,
+		annotations: F.memory_search
+	}, async (e, i) => Z(t, {
+		surface: "mcp_search",
+		toolName: "memory_search",
+		toolArguments: e,
+		query: e.query,
+		limit: e.limit,
+		resolveFilters: () => S(e, n()),
+		requestId: i?.requestId,
+		sourceSessionId: i?.sessionId,
+		invocationIdentity: i?.signal
+	}, (t) => {
+		let n = r.search(e.query, e.limit, t);
+		return {
+			value: { items: n.map((e) => ({
+				id: e.id,
+				title: e.title,
+				kind: e.kind,
+				body: e.body_text,
+				confidence: e.confidence,
+				score: e.score,
+				session_id: e.session_id,
+				metadata: e.metadata
+			})) },
+			memoryIds: n.map((e) => e.id),
+			filters: t
+		};
+	})), e.registerTool("memory_search_index", {
+		description: "Keyword-search memories when you know exact terms or identifiers. Returns compact entries with IDs and titles, without bodies; expand selected IDs with memory_get or memory_get_observations.",
+		inputSchema: Pe,
+		outputSchema: M.memory_search_index,
+		annotations: F.memory_search_index
+	}, async (e, i) => Z(t, {
+		surface: "mcp_search_index",
+		toolName: "memory_search_index",
+		toolArguments: e,
+		query: e.query,
+		limit: e.limit,
+		resolveFilters: () => S(e, n()),
+		requestId: i?.requestId,
+		sourceSessionId: i?.sessionId,
+		invocationIdentity: i?.signal
+	}, (t) => {
+		let n = r.search(e.query, e.limit, t);
+		return {
+			value: { items: n.map((e) => ({
+				id: e.id,
+				kind: e.kind,
+				title: e.title,
+				score: e.score,
+				created_at: e.created_at,
+				session_id: e.session_id,
+				metadata: e.metadata
+			})) },
+			memoryIds: n.map((e) => e.id),
+			filters: t
+		};
+	})), e.registerTool("memory_explain", {
+		description: "Explain search results with detailed scoring breakdown.",
+		inputSchema: Fe,
+		outputSchema: M.memory_explain,
+		annotations: F.memory_explain
+	}, async (e, i) => Z(t, {
+		surface: "mcp_explain",
+		toolName: "memory_explain",
+		toolArguments: e,
+		query: e.query,
+		limit: e.limit,
+		resolveFilters: () => S(e, n()),
+		requestId: i?.requestId,
+		sourceSessionId: i?.sessionId,
+		invocationIdentity: i?.signal
+	}, (t) => {
+		let n = r.explain(e.query ?? null, e.ids ?? null, e.limit, t, { includePackContext: e.include_pack_context }), i = n.errors.some((e) => e.code === "INVALID_ARGUMENT" && e.field === "query");
+		return {
+			value: n,
+			memoryIds: n.items.map((e) => e.id),
+			filters: t,
+			retrievalStatus: i ? "failed" : void 0
+		};
+	})), e.registerTool("memory_recent", {
+		description: "Return recent memories, newest first.",
+		inputSchema: Ie,
+		outputSchema: M.memory_recent,
+		annotations: F.memory_recent
+	}, async (e, i) => Z(t, {
+		surface: "mcp_recent",
+		toolName: "memory_recent",
+		toolArguments: e,
+		limit: e.limit,
+		resolveFilters: () => S(e, n()),
+		requestId: i?.requestId,
+		sourceSessionId: i?.sessionId,
+		invocationIdentity: i?.signal
+	}, (t) => {
+		let n = r.recent(e.limit, t);
+		return {
+			value: { items: n },
+			memoryIds: n.map((e) => e.id),
+			filters: t
+		};
+	})), e.registerTool("memory_pack", {
+		description: "Build a formatted context block for a concept or task using keyword and semantic search when embeddings are available, with automatic keyword-only fallback. Use for conceptually relevant context; use memory_search or memory_search_index for exact identifiers.",
+		inputSchema: Le,
+		outputSchema: M.memory_pack,
+		annotations: F.memory_pack
+	}, async (e, i) => Z(t, {
+		surface: "mcp_pack",
+		toolName: "memory_pack",
+		toolArguments: e,
+		query: e.context,
+		limit: e.limit ?? null,
+		resolveFilters: () => S(e, n()),
+		requestId: i?.requestId,
+		sourceSessionId: i?.sessionId,
+		invocationIdentity: i?.signal
+	}, async (t) => {
+		let n = e.compact || e.compact_detail_count != null || e.compression_mode != null ? {
+			compact: e.compact ?? (e.compact_detail_count != null || void 0),
+			compactDetailCount: e.compact_detail_count,
+			compressionMode: e.compression_mode
+		} : void 0, i = await r.buildMemoryPackAsync(e.context, e.limit ?? void 0, null, t, n), { rendered_items: a, ...o } = i;
+		return {
+			value: o,
+			memoryIds: i.item_ids,
+			filters: t
+		};
+	}));
+}
+//#endregion
+//#region src/tools/timeline.ts
+var ze = {
+	query: v.string().optional().describe("Search query to find anchor"),
+	memory_id: v.number().int().optional().describe("Anchor memory ID"),
+	depth_before: v.number().int().min(0).default(3).describe("Items before anchor"),
+	depth_after: v.number().int().min(0).default(3).describe("Items after anchor"),
+	...E
+}, Be = {
+	ids: v.array(v.union([v.number(), v.string()])).max(200).describe("Memory IDs to expand"),
+	depth_before: v.number().int().min(0).default(3).describe("Timeline items before"),
+	depth_after: v.number().int().min(0).default(3).describe("Timeline items after"),
+	include_observations: v.boolean().default(!1).describe("Include full observation details"),
+	...E
+};
+function Ve(e, t) {
+	let { defaultProject: n, store: r } = t;
+	e.registerTool("memory_timeline", {
+		description: "Get a chronological window of memories around an anchor (by ID or query).",
+		inputSchema: ze,
+		outputSchema: M.memory_timeline,
+		annotations: F.memory_timeline
+	}, async (e, i) => Z(t, {
+		surface: "mcp_timeline",
+		toolName: "memory_timeline",
+		toolArguments: e,
+		query: e.query,
+		limit: e.depth_before + e.depth_after + 1,
+		resolveFilters: () => S(e, n()),
+		requestId: i?.requestId,
+		sourceSessionId: i?.sessionId,
+		invocationIdentity: i?.signal
+	}, (t) => {
+		let n = r.timeline(e.query ?? null, e.memory_id ?? null, e.depth_before, e.depth_after, t);
+		return {
+			value: { items: n },
+			memoryIds: n.map((e) => e.id),
+			filters: t
+		};
+	})), e.registerTool("memory_expand", {
+		description: "Fetch memories by ID with surrounding timeline context.",
+		inputSchema: Be,
+		outputSchema: M.memory_expand,
+		annotations: F.memory_expand
+	}, async (e, i) => Z(t, {
+		surface: "mcp_expand",
+		toolName: "memory_expand",
+		toolArguments: e,
+		limit: e.ids.length,
+		resolveFilters: () => S(e, e.project !== void 0 && !e.project.trim() ? null : n()),
+		requestId: i?.requestId,
+		sourceSessionId: i?.sessionId,
+		invocationIdentity: i?.signal
+	}, (t) => {
+		let n = t?.project ?? null, { ordered: i, invalid: a } = s(e.ids), o = [];
+		a.length > 0 && o.push({
+			code: "INVALID_ARGUMENT",
+			field: "ids",
+			message: "some ids are not valid integers",
+			ids: a
+		});
+		let c = [], u = [], d = [], f = [], p = [], m = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Map();
+		for (let a of i) {
+			let i = r.get(a);
+			if (!i?.active) {
+				c.push(a);
+				continue;
+			}
+			let o = i.session_id;
+			if (n && o > 0) {
+				if (!h.has(o)) {
+					let e = r.db.prepare("SELECT project FROM sessions WHERE id = ? LIMIT 1").get(o);
+					h.set(o, typeof e?.project == "string" ? e.project : null);
+				}
+				if (!l(n, h.get(o) ?? null)) {
+					u.push(a);
+					continue;
+				}
+			} else if (n && o <= 0) {
+				u.push(a);
+				continue;
+			}
+			let s = r.timeline(null, a, e.depth_before, e.depth_after, t), g = s.find((e) => e.id === a);
+			if (!g) {
+				d.push(a);
+				continue;
+			}
+			f.push(g);
+			for (let e of s) {
+				let t = e.id;
+				t <= 0 || m.has(t) || (m.add(t), p.push(e));
+			}
+		}
+		c.length > 0 && o.push({
+			code: "NOT_FOUND",
+			field: "ids",
+			message: "some requested ids were not found",
+			ids: c
+		}), u.length > 0 && o.push({
+			code: "PROJECT_MISMATCH",
+			field: "project",
+			message: "some requested ids are outside the requested project scope",
+			ids: u
+		}), d.length > 0 && o.push({
+			code: "FILTER_MISMATCH",
+			field: "filters",
+			message: "some requested ids are outside the requested filters",
+			ids: d
+		});
+		let g = [];
+		if (e.include_observations) {
+			let e = /* @__PURE__ */ new Set(), n = [];
+			for (let t of [...f, ...p]) t.id > 0 && !e.has(t.id) && (e.add(t.id), n.push(t.id));
+			g = $(r, n, t);
+		}
+		return {
+			value: {
+				anchors: f,
+				timeline: p,
+				observations: g,
+				missing_ids: i.filter((e) => c.includes(e) || u.includes(e) || d.includes(e)),
+				errors: o,
+				metadata: {
+					project: n,
+					requested_ids_count: i.length,
+					returned_anchor_count: f.length,
+					timeline_count: p.length,
+					include_observations: e.include_observations
+				}
+			},
+			memoryIds: [...new Set([
+				...f,
+				...p,
+				...g
+			].map((e) => e.id))],
+			filters: t
+		};
+	}));
+}
+//#endregion
+//#region src/server.ts
+function He(e, n = {}) {
+	let r = new ne({
+		name: "codemem",
+		version: a
+	}), i = {
+		store: e,
+		defaultProject: () => n.resolveDefaultProject ? n.resolveDefaultProject() : n.defaultProject === void 0 ? x() : n.defaultProject,
+		envProject: () => n.envProject === void 0 ? process.env.CODEMEM_PROJECT ?? null : n.envProject,
+		captureRetrievalLedger: n.captureRetrievalLedger !== !1,
+		retrievalLedgerScopeId: n.retrievalLedgerScopeId ?? t(),
+		retrievalLedgerIdentityMode: n.retrievalLedgerIdentityMode ?? "session"
+	};
+	return Re(r, i), Ve(r, i), B(r, i), ke(r, i), Me(r), je(r), r;
+}
+//#endregion
+export { y as n, He as t };
+
+//# sourceMappingURL=server-DmdZAo6k.js.map