@codemem/mcp 0.40.0-alpha.1 → 0.40.1

package/dist/server-BshtPXit.js

@@ -0,0 +1,876 @@
+import { createHash as e, randomUUID as t } from "node:crypto";
+import { ObserverClient as n, VERSION as r, buildDistillReport as i, dedupeOrderedIds as a, judgeDistillReport as o, projectMatchesFilter as s, reconcileFailedRetrievalSurface as c, recordRetrievalSurface as l, resolveProject as u, resolveProjectRoot as d, storeVectors as f, toJson as p } from "@codemem/core";
+import { existsSync as m, readFileSync as h } from "node:fs";
+import { homedir as g } from "node:os";
+import { join as _ } from "node:path";
+import { McpServer as v } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as y } from "zod";
+//#region src/canonical-json.ts
+function b(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 x(e) {
+	return e?.trim() || null;
+}
+function S() {
+	return x(process.env.CODEMEM_PROJECT) ?? u(process.cwd());
+}
+function C(e) {
+	return x(e.project) ?? x(e.envProject) ?? null;
+}
+function w(e, t = S()) {
+	let n = {}, r = !1, i = (typeof e.project == "string" ? x(e.project) : void 0) || x(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 T(e) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(e)
+	}] };
+}
+function E(e) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: e })
+	}] };
+}
+//#endregion
+//#region src/schemas.ts
+var ee = {
+	scope_id: y.string().optional().describe("Filter by a single sharing domain scope_id"),
+	include_scope_ids: y.array(y.string()).optional().describe("Sharing domain scope_ids to include"),
+	exclude_scope_ids: y.array(y.string()).optional().describe("Sharing domain scope_ids to exclude")
+}, D = {
+	kind: y.string().optional().describe("Filter by memory kind"),
+	project: y.string().optional().describe("Filter by project scope (matches sessions.project)"),
+	...ee,
+	visibility: y.array(y.string()).optional(),
+	include_visibility: y.array(y.string()).optional(),
+	exclude_visibility: y.array(y.string()).optional(),
+	include_workspace_ids: y.array(y.string()).optional(),
+	exclude_workspace_ids: y.array(y.string()).optional(),
+	include_workspace_kinds: y.array(y.string()).optional(),
+	exclude_workspace_kinds: y.array(y.string()).optional(),
+	include_actor_ids: y.array(y.string()).optional(),
+	exclude_actor_ids: y.array(y.string()).optional(),
+	include_trust_states: y.array(y.string()).optional(),
+	exclude_trust_states: y.array(y.string()).optional(),
+	ownership_scope: y.string().optional(),
+	personal_first: y.union([y.boolean(), y.string()]).optional(),
+	trust_bias: y.string().optional(),
+	widen_shared_when_weak: y.union([y.boolean(), y.string()]).optional(),
+	widen_shared_min_personal_results: y.number().int().optional(),
+	widen_shared_min_personal_score: y.number().optional()
+}, O = y.enum([
+	"discovery",
+	"change",
+	"feature",
+	"bugfix",
+	"refactor",
+	"decision",
+	"exploration"
+]), k = Object.keys(D).toSorted();
+//#endregion
+//#region src/tools/distill.ts
+function A(e, t, n) {
+	if (!m(e)) return null;
+	let r = h(e, "utf8");
+	return r.trim() ? {
+		path: t,
+		text: r,
+		scope: n
+	} : null;
+}
+function j(e, t = process.cwd()) {
+	let n = d(t) ?? t;
+	return [e ? A(_(n, "AGENTS.md"), "AGENTS.md", "project") : null, A(_(g(), ".config", "opencode", "AGENTS.md"), "~/.config/opencode/AGENTS.md", "user")].filter((e) => e != null);
+}
+function M(e, t) {
+	if (e.all_projects) return !1;
+	let n = u(process.cwd());
+	if (!n) return !1;
+	let r = typeof e.project == "string" ? e.project.trim() : "", i = r ? u(process.cwd(), r) : t;
+	return i ? s(i, n) : !1;
+}
+function N(e, t) {
+	if (e.all_projects && typeof e.project == "string" && e.project.trim()) throw Error("project cannot be combined with all_projects");
+	return w(e, e.all_projects ? null : t);
+}
+function te(e, t) {
+	let { defaultProject: r, store: a } = t;
+	e.tool("memory_distill_candidates", "Mine recurring memories into reviewable context candidates. Read-only; does not modify context files.", {
+		limit: y.number().int().min(1).max(50).default(10).describe("Max candidates"),
+		min_recurrence: y.number().int().min(1).max(50).default(2).describe("Minimum member count per candidate"),
+		all_projects: y.boolean().default(!1).describe("Mine memories across all projects"),
+		include_documented: y.boolean().default(!1).describe("Include candidates already represented in context files"),
+		max_evidence_items: y.number().int().min(1).max(20).default(5).describe("Evidence snippets per candidate"),
+		judge: y.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)"),
+		...D
+	}, async (e) => {
+		try {
+			let t = r(), s = N(e, t), c = e.kind ? [e.kind] : void 0, l = e.judge ? Math.min(e.limit * 3, e.limit + 20) : e.limit, u = await i(a, {
+				candidate: {
+					includeDocumented: e.include_documented,
+					maxEvidenceItems: e.max_evidence_items
+				},
+				contextDocuments: j(M(e, t)),
+				corpus: {
+					filters: s ?? null,
+					kinds: c
+				},
+				limit: l,
+				minRecurrence: e.min_recurrence
+			});
+			if (e.judge) {
+				try {
+					let e = new n();
+					u = await o(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 T(u);
+		} catch (e) {
+			return E(e instanceof Error ? e.message : String(e));
+		}
+	});
+}
+//#endregion
+//#region src/mcp-retrieval-ledger.ts
+var ne = 300 * 1e3, re = 2e3, P = /* @__PURE__ */ new WeakMap(), F = 0;
+function I(e, t, n) {
+	if (e.captureRetrievalLedger) try {
+		let r = l(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") && c(e.store.db, t);
+	} catch {}
+}
+function L(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 R(t, n) {
+	if (n.requestId == null) return null;
+	let r = e("sha256").update(b({
+		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 z(e) {
+	let t = P.get(e);
+	return t || (t = {
+		byInvocation: /* @__PURE__ */ new WeakMap(),
+		activeByRequest: /* @__PURE__ */ new Map(),
+		pendingFailures: /* @__PURE__ */ new Map(),
+		pendingFailureCount: 0,
+		nextPendingFailureOrder: 0,
+		nextInvocationSequence: 0
+	}, P.set(e, t)), t;
+}
+function B(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 > re;) {
+		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 V(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 H(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 U(e, t, n, r) {
+	let i = e.pendingFailures.get(t) ?? [];
+	i.some((e) => e.identity.attemptId === n.attemptId) || (i.push({
+		identity: n,
+		expiresAt: r + ne,
+		order: e.nextPendingFailureOrder
+	}), e.nextPendingFailureOrder += 1, e.pendingFailures.set(t, i), e.pendingFailureCount += 1, B(e, r));
+}
+function W() {
+	try {
+		return {
+			baseRequestId: null,
+			requestId: null,
+			attemptId: t()
+		};
+	} catch {
+		let e = Date.now().toString(16).slice(-8).padStart(8, "0"), t = F.toString(16).slice(-4).padStart(4, "0");
+		return F = (F + 1) % 65536, {
+			baseRequestId: null,
+			requestId: null,
+			attemptId: `00000000-0000-4000-8000-${e}${t}`
+		};
+	}
+}
+function G(t, n) {
+	let r = R(t, n);
+	if (t.retrievalLedgerIdentityMode === "stateless" || r == null) return {
+		baseRequestId: r,
+		requestId: r,
+		attemptId: L(r)
+	};
+	let i = z(t);
+	B(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 ? V(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: L(a)
+			};
+		}
+		n.invocationIdentity && i.byInvocation.set(n.invocationIdentity, o);
+	}
+	return i.activeByRequest.set(r, (i.activeByRequest.get(r) ?? 0) + 1), o;
+}
+function K(e, t) {
+	try {
+		return G(e, t);
+	} catch {
+		return W();
+	}
+}
+function q(e, t, n) {
+	if (e.retrievalLedgerIdentityMode === "stateless" || t.baseRequestId == null) return;
+	let r = z(e), i = r.activeByRequest.get(t.baseRequestId) ?? 0;
+	i <= 1 ? r.activeByRequest.delete(t.baseRequestId) : r.activeByRequest.set(t.baseRequestId, i - 1), n === "failed" ? U(r, t.baseRequestId, t, Date.now()) : H(r, t.baseRequestId, t.attemptId);
+}
+function J(e, t, n) {
+	try {
+		q(e, t, n);
+	} catch {}
+}
+async function Y(e, t, n) {
+	let r = K(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 ? E(c.error) : T(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 I(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), J(e, r, m ? "failed" : "completed"), u;
+	} catch (n) {
+		let c = /* @__PURE__ */ new Date(), l = t.sourceSessionId ?? e.retrievalLedgerScopeId;
+		return I(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), J(e, r, "failed"), E(n instanceof Error ? n.message : String(n));
+	}
+}
+//#endregion
+//#region src/memory-access.ts
+function X(e, t, n) {
+	return e.timeline(null, t, 0, 0, n ?? null).find((e) => e.id === t) ?? null;
+}
+function Z(e, t, n) {
+	if (t.length === 0) return [];
+	let r = [];
+	for (let i of t) {
+		let t = X(e, i, n);
+		t && r.push(t);
+	}
+	return r;
+}
+function ie(e, t, n) {
+	return X(e, t, n) ? (e.forget(t), !0) : !1;
+}
+function ae(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 = C({
+			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", p({ mcp: !0 })), c = Number(s.lastInsertRowid), l = e.remember(c, t.kind, t.title, t.body, t.confidence);
+		if (!X(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(), p({ mcp: !0 }), c), {
+			memId: l,
+			title: t.title,
+			body: t.body
+		};
+	})();
+}
+//#endregion
+//#region src/tools/items.ts
+function oe(e, t) {
+	let { envProject: n, store: r } = t;
+	e.tool("memory_get", "Fetch a single memory item by ID.", {
+		memory_id: y.number().int().describe("Memory ID"),
+		...D
+	}, async (e, n) => Y(t, {
+		surface: "mcp_get",
+		toolName: "memory_get",
+		toolArguments: e,
+		limit: 1,
+		resolveFilters: () => w(e, null),
+		requestId: n?.requestId,
+		sourceSessionId: n?.sessionId,
+		invocationIdentity: n?.signal
+	}, (t) => {
+		let n = X(r, e.memory_id, t);
+		return n ? {
+			value: n,
+			memoryIds: [n.id],
+			filters: t
+		} : {
+			value: null,
+			memoryIds: [],
+			error: "not_found",
+			filters: t
+		};
+	})), e.tool("memory_get_observations", "Fetch multiple memory items by their IDs.", {
+		ids: y.array(y.number().int()).max(200).describe("Memory IDs to fetch"),
+		...D
+	}, async (e, n) => Y(t, {
+		surface: "mcp_get_observations",
+		toolName: "memory_get_observations",
+		toolArguments: e,
+		limit: e.ids.length,
+		resolveFilters: () => w(e, null),
+		requestId: n?.requestId,
+		sourceSessionId: n?.sessionId,
+		invocationIdentity: n?.signal
+	}, (t) => {
+		let n = Z(r, e.ids, t);
+		return {
+			value: { items: n },
+			memoryIds: n.map((e) => e.id),
+			filters: t
+		};
+	})), e.tool("memory_remember", "Create a new memory. Use for milestones, decisions, and notable facts.", {
+		kind: O.describe("Memory kind"),
+		title: y.string().describe("Short title"),
+		body: y.string().describe("Body text (high-signal content)"),
+		confidence: y.number().min(0).max(1).default(.5).describe("Confidence 0-1"),
+		project: y.string().optional().describe("Project identifier")
+	}, async (e) => {
+		try {
+			let t = ae(r, e, { envProject: n() });
+			try {
+				await f(r.db, t.memId, t.title, t.body);
+			} catch {}
+			return T({ id: t.memId });
+		} catch (e) {
+			return E(e instanceof Error ? e.message : String(e));
+		}
+	}), e.tool("memory_forget", "Soft-delete a memory item. Use for incorrect or sensitive data.", {
+		memory_id: y.number().int().describe("Memory ID to forget"),
+		...D
+	}, async (e) => {
+		try {
+			return ie(r, e.memory_id, w(e, null)) ? T({ status: "ok" }) : E("not_found");
+		} catch (e) {
+			return E(e instanceof Error ? e.message : String(e));
+		}
+	});
+}
+//#endregion
+//#region src/tools/learn.ts
+function se(e) {
+	e.tool("memory_learn", "Learn how to use codemem memory tools. Call this first if unfamiliar.", {}, async () => T({
+		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_index to get compact candidates.",
+				"Use memory.timeline to expand around a promising memory.",
+				"Use memory.get_observations for full details only when needed.",
+				"Use memory.pack for quick one-shot context blocks.",
+				"Use the project filter unless the user requests cross-project context."
+			],
+			examples: [
+				"memory.search_index(\"billing cache bug\", limit=5)",
+				"memory.timeline(memory_id=123)",
+				"memory.get_observations([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: ["Accidental or sensitive data stored in memory items.", "Obsolete or incorrect items that should no longer surface."],
+			how: ["Call memory.forget(id) to mark the item inactive.", "Prefer forgetting over overwriting to preserve auditability."],
+			examples: ["memory.forget(123)"]
+		},
+		prompt_hint: "At task start: call memory.search_index; 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,",
+			"immediately call memory.search_index; then use memory.timeline + memory.get_observations;",
+			"at milestones, call memory.remember; use memory.forget for incorrect/sensitive items.",
+			"",
+			"System prompt:",
+			"You have access to codemem MCP tools. If unfamiliar, call memory.learn first.",
+			"",
+			"Recall:",
+			"- Start of any task: call memory.search_index with a concise task query.",
+			"- If prior work is referenced (\"as before\", \"last time\", \"we already did…\", \"regression\"),",
+			"  call memory.search_index or memory.timeline.",
+			"- Use memory.get_observations only after filtering IDs.",
+			"- Prefer project-scoped queries unless the user asks for cross-project.",
+			"",
+			"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(id) for incorrect or sensitive items.",
+			"",
+			"Examples:",
+			"- memory.search_index(\"billing cache bug\")",
+			"- memory.timeline(memory_id=123)",
+			"- memory.get_observations([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(123)"
+		].join("\n")
+	}));
+}
+//#endregion
+//#region src/memory-kinds.ts
+var Q = {
+	discovery: "Something learned about the codebase, architecture, or tools",
+	change: "A code change that was made",
+	feature: "A new feature that was implemented",
+	bugfix: "A bug that was found and fixed",
+	refactor: "Code that was refactored or restructured",
+	decision: "A design or architecture decision",
+	exploration: "An experiment or investigation (may not have shipped)"
+};
+//#endregion
+//#region src/tools/schema.ts
+function ce(e) {
+	e.tool("memory_schema", "Return the memory schema — kinds, fields, and available filters.", {}, async () => T({
+		kinds: Object.keys(Q),
+		kind_descriptions: Q,
+		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: k
+	}));
+}
+//#endregion
+//#region src/tools/search.ts
+function le(e, t) {
+	let { defaultProject: n, store: r } = t;
+	e.tool("memory_search", "Search memories by text query. Returns full body text for each match.", {
+		query: y.string().describe("Search query"),
+		limit: y.number().int().min(1).max(50).default(5).describe("Max results"),
+		...D
+	}, async (e, i) => Y(t, {
+		surface: "mcp_search",
+		toolName: "memory_search",
+		toolArguments: e,
+		query: e.query,
+		limit: e.limit,
+		resolveFilters: () => w(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.tool("memory_search_index", "Search memories by text query. Returns compact index entries (no body) for browsing.", {
+		query: y.string().describe("Search query"),
+		limit: y.number().int().min(1).max(50).default(8).describe("Max results"),
+		...D
+	}, async (e, i) => Y(t, {
+		surface: "mcp_search_index",
+		toolName: "memory_search_index",
+		toolArguments: e,
+		query: e.query,
+		limit: e.limit,
+		resolveFilters: () => w(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.tool("memory_explain", "Explain search results with detailed scoring breakdown.", {
+		query: y.string().optional().describe("Search query"),
+		ids: y.array(y.number().int()).max(200).optional().describe("Specific memory IDs to explain"),
+		limit: y.number().int().min(1).max(50).default(10).describe("Max results"),
+		include_pack_context: y.boolean().default(!1).describe("Include formatted pack context"),
+		...D
+	}, async (e, i) => Y(t, {
+		surface: "mcp_explain",
+		toolName: "memory_explain",
+		toolArguments: e,
+		query: e.query,
+		limit: e.limit,
+		resolveFilters: () => w(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.tool("memory_recent", "Return recent memories, newest first.", {
+		limit: y.number().int().min(1).max(100).default(8).describe("Max results"),
+		...D
+	}, async (e, i) => Y(t, {
+		surface: "mcp_recent",
+		toolName: "memory_recent",
+		toolArguments: e,
+		limit: e.limit,
+		resolveFilters: () => w(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.tool("memory_pack", "Build a formatted memory pack from search results — quick one-shot context block.", {
+		context: y.string().describe("Context description to search for"),
+		limit: y.number().int().min(1).max(50).optional().describe("Max items to include"),
+		compact: y.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: y.number().int().min(0).max(50).optional().describe("Number of items to show in full detail in compact mode (default 3)"),
+		compression_mode: y.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."),
+		...D
+	}, async (e, i) => Y(t, {
+		surface: "mcp_pack",
+		toolName: "memory_pack",
+		toolArguments: e,
+		query: e.context,
+		limit: e.limit ?? null,
+		resolveFilters: () => w(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 : !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);
+		return {
+			value: i,
+			memoryIds: i.item_ids,
+			filters: t
+		};
+	}));
+}
+//#endregion
+//#region src/tools/timeline.ts
+function $(e, t) {
+	let { defaultProject: n, store: r } = t;
+	e.tool("memory_timeline", "Get a chronological window of memories around an anchor (by ID or query).", {
+		query: y.string().optional().describe("Search query to find anchor"),
+		memory_id: y.number().int().optional().describe("Anchor memory ID"),
+		depth_before: y.number().int().min(0).default(3).describe("Items before anchor"),
+		depth_after: y.number().int().min(0).default(3).describe("Items after anchor"),
+		...D
+	}, async (e, i) => Y(t, {
+		surface: "mcp_timeline",
+		toolName: "memory_timeline",
+		toolArguments: e,
+		query: e.query,
+		limit: e.depth_before + e.depth_after + 1,
+		resolveFilters: () => w(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.tool("memory_expand", "Fetch memories by ID with surrounding timeline context.", {
+		ids: y.array(y.union([y.number(), y.string()])).max(200).describe("Memory IDs to expand"),
+		depth_before: y.number().int().min(0).default(3).describe("Timeline items before"),
+		depth_after: y.number().int().min(0).default(3).describe("Timeline items after"),
+		include_observations: y.boolean().default(!1).describe("Include full observation details"),
+		...D
+	}, async (e, i) => Y(t, {
+		surface: "mcp_expand",
+		toolName: "memory_expand",
+		toolArguments: e,
+		limit: e.ids.length,
+		resolveFilters: () => w(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: o } = a(e.ids), c = [];
+		o.length > 0 && c.push({
+			code: "INVALID_ARGUMENT",
+			field: "ids",
+			message: "some ids are not valid integers",
+			ids: o
+		});
+		let l = [], 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) {
+				l.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 (!s(n, h.get(o) ?? null)) {
+					u.push(a);
+					continue;
+				}
+			} else if (n && o <= 0) {
+				u.push(a);
+				continue;
+			}
+			let c = r.timeline(null, a, e.depth_before, e.depth_after, t), g = c.find((e) => e.id === a);
+			if (!g) {
+				d.push(a);
+				continue;
+			}
+			f.push(g);
+			for (let e of c) {
+				let t = e.id;
+				t <= 0 || m.has(t) || (m.add(t), p.push(e));
+			}
+		}
+		l.length > 0 && c.push({
+			code: "NOT_FOUND",
+			field: "ids",
+			message: "some requested ids were not found",
+			ids: l
+		}), u.length > 0 && c.push({
+			code: "PROJECT_MISMATCH",
+			field: "project",
+			message: "some requested ids are outside the requested project scope",
+			ids: u
+		}), d.length > 0 && c.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 = Z(r, n, t);
+		}
+		return {
+			value: {
+				anchors: f,
+				timeline: p,
+				observations: g,
+				missing_ids: i.filter((e) => l.includes(e) || u.includes(e) || d.includes(e)),
+				errors: c,
+				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 ue(e, n = {}) {
+	let i = new v({
+		name: "codemem",
+		version: r
+	}), a = {
+		store: e,
+		defaultProject: () => n.resolveDefaultProject ? n.resolveDefaultProject() : n.defaultProject === void 0 ? S() : 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 le(i, a), $(i, a), te(i, a), oe(i, a), ce(i), se(i), i;
+}
+//#endregion
+export { b as n, ue as t };
+
+//# sourceMappingURL=server-BshtPXit.js.map