#1 Persistent memory for AI coding agents based on real-world benchmarks
TypeScript agentmemoryagentsaiclaudeclaudecodecodexcopilotcursorgenaiharnesshermesmemoryompopenclawopencodepi
feat: agentmemory v0.4.0 — MCP resources, prompts, enrichment, confidence (#7)
Rohit Ghumare8b21ae2bf661
diff --git a/package.json b/package.jsonindex f146abe7..0506557b 100644--- a/package.json+++ b/package.json@@ -1,6 +1,6 @@{"name": "agentmemory",- "version": "0.3.0",+ "version": "0.4.0","description": "Persistent memory for AI coding agents, powered by iii-engine's three primitives","type": "module","main": "dist/index.js",diff --git a/plugin/scripts/pre-tool-use.mjs b/plugin/scripts/pre-tool-use.mjsindex 5cd84f9a..aa9432b0 100755--- a/plugin/scripts/pre-tool-use.mjs+++ b/plugin/scripts/pre-tool-use.mjs@@ -38,14 +38,21 @@ async function main() {if (typeof val === "string" && val.length > 0) files.push(val);}if (files.length === 0) return;+ const terms = [];+ if (toolName === "Grep" || toolName === "Glob") {+ const pattern = toolInput["pattern"];+ if (typeof pattern === "string" && pattern.length > 0) terms.push(pattern);+ }const sessionId = data.session_id || "unknown";try {- const res = await fetch(`${REST_URL}/agentmemory/file-context`, {+ const res = await fetch(`${REST_URL}/agentmemory/enrich`, {method: "POST",headers: authHeaders(),body: JSON.stringify({sessionId,- files+ files,+ terms,+ toolName}),signal: AbortSignal.timeout(2e3)});diff --git a/src/functions/enrich.ts b/src/functions/enrich.tsnew file mode 100644index 00000000..bce4d654--- /dev/null+++ b/src/functions/enrich.ts@@ -0,0 +1,132 @@+import type { ISdk } from "iii-sdk";+import { getContext } from "iii-sdk";+import type { Memory } from "../types.js";+import { KV } from "../state/schema.js";+import { StateKV } from "../state/kv.js";++const MAX_CONTEXT_LENGTH = 4000;++function escapeXml(s: string): string {+ return s+ .replace(/&/g, "&")+ .replace(/</g, "<")+ .replace(/>/g, ">")+ .replace(/"/g, """)+ .replace(/'/g, "'");+}++export function registerEnrichFunction(sdk: ISdk, kv: StateKV): void {+ sdk.registerFunction(+ {+ id: "mem::enrich",+ description:+ "Aggregate file context, relevant observations, and bug memories for pre-tool enrichment",+ },+ async (data: {+ sessionId: string;+ files: string[];+ terms?: string[];+ toolName?: string;+ }) => {+ const ctx = getContext();+ const parts: string[] = [];++ const fileContextPromise = sdk+ .trigger<{ sessionId: string; files: string[] }, { context: string }>(+ "mem::file-context",+ {+ sessionId: data.sessionId,+ files: data.files,+ },+ )+ .catch(() => ({ context: "" }));++ const searchQueries: string[] = [+ ...data.files.map((f) => f.split("/").pop() || f),+ ...(data.terms || []),+ ].filter((q) => q.length > 0);++ const searchPromise =+ searchQueries.length > 0+ ? sdk+ .trigger<+ { query: string; limit: number },+ { results: Array<{ observation: { narrative: string } }> }+ >("mem::search", {+ query: searchQueries.join(" "),+ limit: 5,+ })+ .catch(() => ({ results: [] }))+ : Promise.resolve({ results: [] });++ const bugMemoriesPromise = kv+ .list<Memory>(KV.memories)+ .then((memories) =>+ memories+ .filter(+ (m) =>+ m.type === "bug" &&+ m.isLatest &&+ m.files.some((f) =>+ data.files.some((df) => f.includes(df) || df.includes(f)),+ ),+ )+ .sort(+ (a, b) =>+ new Date(b.updatedAt || b.createdAt).getTime() -+ new Date(a.updatedAt || a.createdAt).getTime(),+ ),+ )+ .catch(() => []);++ const [fileContext, searchResult, bugMemories] = await Promise.all([+ fileContextPromise,+ searchPromise,+ bugMemoriesPromise,+ ]);++ if (fileContext.context) {+ parts.push(fileContext.context);+ }++ if (searchResult.results.length > 0) {+ const observations = searchResult.results+ .map((r) => r.observation?.narrative)+ .filter(Boolean)+ .map((n) => escapeXml(n as string))+ .join("\n");+ if (observations) {+ parts.push(+ `<agentmemory-relevant-context>\n${observations}\n</agentmemory-relevant-context>`,+ );+ }+ }++ if (bugMemories.length > 0) {+ const bugs = bugMemories+ .slice(0, 3)+ .map((m) => `- ${escapeXml(m.title)}: ${escapeXml(m.content)}`)+ .join("\n");+ parts.push(+ `<agentmemory-past-errors>\n${bugs}\n</agentmemory-past-errors>`,+ );+ }++ let context = parts.join("\n\n");+ let truncated = false;+ if (context.length > MAX_CONTEXT_LENGTH) {+ context = context.slice(0, MAX_CONTEXT_LENGTH);+ truncated = true;+ }++ ctx.logger.info("Enrichment completed", {+ sessionId: data.sessionId,+ fileCount: data.files.length,+ contextLength: context.length,+ truncated,+ });++ return { context, truncated };+ },+ );+}diff --git a/src/functions/relations.ts b/src/functions/relations.tsindex dcb6af7d..82d363e3 100644--- a/src/functions/relations.ts+++ b/src/functions/relations.ts@@ -4,6 +4,35 @@ import type { Memory, MemoryRelation } from "../types.js";import { KV, generateId } from "../state/schema.js";import { StateKV } from "../state/kv.js";+function computeConfidence(+ source: Memory,+ target: Memory,+ relationType: MemoryRelation["type"],+): number {+ let score = 0.5;++ const sharedSessions = source.sessionIds.filter((sid) =>+ target.sessionIds.includes(sid),+ );+ score += Math.min(sharedSessions.length * 0.1, 0.3);++ const now = Date.now();+ const sourceAge = now - new Date(source.updatedAt).getTime();+ const targetAge = now - new Date(target.updatedAt).getTime();+ const sevenDays = 7 * 24 * 60 * 60 * 1000;+ const ninetyDays = 90 * 24 * 60 * 60 * 1000;+ if (sourceAge < sevenDays && targetAge < sevenDays) {+ score += 0.1;+ } else if (sourceAge > ninetyDays && targetAge > ninetyDays) {+ score -= 0.1;+ }++ if (relationType === "supersedes") score += 0.1;+ if (relationType === "contradicts") score -= 0.05;++ return Math.max(0, Math.min(1, score));+}+export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {sdk.registerFunction({@@ -14,6 +43,7 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {sourceId: string;targetId: string;type: MemoryRelation["type"];+ confidence?: number;}) => {const ctx = getContext();@@ -23,11 +53,17 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {return { success: false, error: "source or target memory not found" };}+ const confidence =+ data.confidence !== undefined+ ? Math.max(0, Math.min(1, data.confidence))+ : computeConfidence(source, target, data.type);+const relation: MemoryRelation = {type: data.type,sourceId: data.sourceId,targetId: data.targetId,createdAt: new Date().toISOString(),+ confidence,};const relationId = generateId("rel");@@ -93,6 +129,7 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {sourceId: evolved.id,targetId: existing.id,createdAt: now,+ confidence: 1.0,};await kv.set(KV.relations, generateId("rel"), relation);@@ -110,17 +147,29 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {id: "mem::get-related",description: "Get related memories within N hops",},- async (data: { memoryId: string; maxHops?: number }) => {+ async (data: {+ memoryId: string;+ maxHops?: number;+ minConfidence?: number;+ }) => {const ctx = getContext();const maxHops = Math.min(data.maxHops ?? 2, 5);const MAX_VISITED = 500;+ const rawMinConf = Number(data.minConfidence);+ const minConfidence = Number.isFinite(rawMinConf)+ ? Math.max(0, Math.min(1, rawMinConf))+ : 0;const allRelations = await kv.list<MemoryRelation>(KV.relations).catch(() => []);const visited = new Set<string>();- const result: Array<{ memory: Memory; hop: number }> = [];+ const result: Array<{+ memory: Memory;+ hop: number;+ confidence: number;+ }> = [];const queue: Array<{ id: string; hop: number }> = [{ id: data.memoryId, hop: 0 },];@@ -134,7 +183,18 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {if (!memory) continue;if (current.hop > 0) {- result.push({ memory, hop: current.hop });+ const matchingRelations = allRelations.filter(+ (r) =>+ (r.sourceId === current.id && visited.has(r.targetId)) ||+ (r.targetId === current.id && visited.has(r.sourceId)),+ );+ const confidence =+ matchingRelations.length > 0+ ? Math.max(...matchingRelations.map((r) => r.confidence ?? 0.5))+ : 0.5;+ if (confidence >= minConfidence) {+ result.push({ memory, hop: current.hop, confidence });+ }}const relatedIds = memory.relatedIds || [];@@ -156,6 +216,8 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {}}+ result.sort((a, b) => b.confidence - a.confidence);+ctx.logger.info("Related memories retrieved", {memoryId: data.memoryId,found: result.length,diff --git a/src/hooks/pre-tool-use.ts b/src/hooks/pre-tool-use.tsindex dbc4a9c0..10ddde5b 100644--- a/src/hooks/pre-tool-use.ts+++ b/src/hooks/pre-tool-use.ts@@ -40,13 +40,21 @@ async function main() {}if (files.length === 0) return;+ const terms: string[] = [];+ if (toolName === "Grep" || toolName === "Glob") {+ const pattern = toolInput["pattern"];+ if (typeof pattern === "string" && pattern.length > 0) {+ terms.push(pattern);+ }+ }+const sessionId = (data.session_id as string) || "unknown";try {- const res = await fetch(`${REST_URL}/agentmemory/file-context`, {+ const res = await fetch(`${REST_URL}/agentmemory/enrich`, {method: "POST",headers: authHeaders(),- body: JSON.stringify({ sessionId, files }),+ body: JSON.stringify({ sessionId, files, terms, toolName }),signal: AbortSignal.timeout(2000),});diff --git a/src/index.ts b/src/index.tsindex ac3f6b74..8b085a44 100644--- a/src/index.ts+++ b/src/index.ts@@ -36,6 +36,7 @@ import { registerSmartSearchFunction } from "./functions/smart-search.js";import { registerProfileFunction } from "./functions/profile.js";import { registerAutoForgetFunction } from "./functions/auto-forget.js";import { registerExportImportFunction } from "./functions/export-import.js";+import { registerEnrichFunction } from "./functions/enrich.js";import { registerApiTriggers } from "./triggers/api.js";import { registerEventTriggers } from "./triggers/events.js";import { registerMcpEndpoints } from "./mcp/server.js";@@ -56,7 +57,7 @@ async function main() {const embeddingProvider = createEmbeddingProvider();- console.log(`[agentmemory] Starting worker v0.3.0...`);+ console.log(`[agentmemory] Starting worker v0.4.0...`);console.log(`[agentmemory] Engine: ${config.engineUrl}`);console.log(`[agentmemory] Provider: ${config.provider.provider} (${config.provider.model})`,@@ -113,6 +114,7 @@ async function main() {registerProfileFunction(sdk, kv);registerAutoForgetFunction(sdk, kv);registerExportImportFunction(sdk, kv);+ registerEnrichFunction(sdk, kv);const bm25Index = getSearchIndex();const hybridSearch = new HybridSearch(@@ -171,7 +173,9 @@ async function main() {console.log(`[agentmemory] Ready. ${embeddingProvider ? "Hybrid" : "BM25"} search active.`,);- console.log(`[agentmemory] Endpoints: 28 REST + 10 MCP tools + 21 functions`);+ console.log(+ `[agentmemory] Endpoints: 29 REST + 10 MCP tools + 4 MCP resources + 3 MCP prompts + 22 functions`,+ );const shutdown = async () => {console.log(`\n[agentmemory] Shutting down...`);diff --git a/src/mcp/server.ts b/src/mcp/server.tsindex de00b0b5..433a69dc 100644--- a/src/mcp/server.ts+++ b/src/mcp/server.ts@@ -1,6 +1,12 @@import type { ISdk, ApiRequest } from "iii-sdk";import type { StateKV } from "../state/kv.js";import { KV } from "../state/schema.js";+import type {+ SessionSummary,+ Memory,+ Session,+ MemoryRelation,+} from "../types.js";type McpTool = {name: string;@@ -204,6 +210,11 @@ const MCP_TOOLS: McpTool[] = [type: "number",description: "Maximum graph traversal depth (default 2)",},+ minConfidence: {+ type: "number",+ description:+ "Minimum confidence threshold to include (0-1, default 0)",+ },},required: ["memoryId"],},@@ -456,9 +467,14 @@ export function registerMcpEndpoints(body: { error: "memoryId is required for memory_relations" },};}+ const rawMaxHops = Number(args.maxHops);+ const rawMinConf = Number(args.minConfidence);const result = await sdk.trigger("mem::get-related", {memoryId: args.memoryId,- maxHops: (args.maxHops as number) || 2,+ maxHops: Number.isFinite(rawMaxHops) ? rawMaxHops : 2,+ minConfidence: Number.isFinite(rawMinConf)+ ? Math.max(0, Math.min(1, rawMinConf))+ : 0,});return {status_code: 200,@@ -491,4 +507,371 @@ export function registerMcpEndpoints(function_id: "mcp::tools::call",config: { api_path: "/agentmemory/mcp/call", http_method: "POST" },});++ const MCP_RESOURCES = [+ {+ uri: "agentmemory://status",+ name: "Agent Memory Status",+ description: "Current session count, memory count, and health status",+ mimeType: "application/json",+ },+ {+ uri: "agentmemory://project/{name}/profile",+ name: "Project Profile",+ description:+ "Top concepts, frequently modified files, and conventions for a project",+ mimeType: "application/json",+ },+ {+ uri: "agentmemory://project/{name}/recent",+ name: "Recent Sessions",+ description: "Last 5 session summaries for a project",+ mimeType: "application/json",+ },+ {+ uri: "agentmemory://memories/latest",+ name: "Latest Memories",+ description: "Top 10 latest memories with their type and strength",+ mimeType: "application/json",+ },+ ];++ sdk.registerFunction(+ { id: "mcp::resources::list" },+ async (req: ApiRequest): Promise<McpResponse> => {+ const authErr = checkAuth(req, secret);+ if (authErr) return authErr;+ return { status_code: 200, body: { resources: MCP_RESOURCES } };+ },+ );+ sdk.registerTrigger({+ type: "http",+ function_id: "mcp::resources::list",+ config: { api_path: "/agentmemory/mcp/resources", http_method: "GET" },+ });++ sdk.registerFunction(+ { id: "mcp::resources::read" },+ async (req: ApiRequest<{ uri: string }>): Promise<McpResponse> => {+ const authErr = checkAuth(req, secret);+ if (authErr) return authErr;++ const uri = req.body?.uri;+ if (!uri || typeof uri !== "string") {+ return { status_code: 400, body: { error: "uri is required" } };+ }++ try {+ if (uri === "agentmemory://status") {+ const sessions = await kv.list<Session>(KV.sessions);+ const memories = await kv.list<Memory>(KV.memories);+ const healthData = await kv.list(KV.health).catch(() => []);+ return {+ status_code: 200,+ body: {+ contents: [+ {+ uri,+ mimeType: "application/json",+ text: JSON.stringify({+ sessionCount: sessions.length,+ memoryCount: memories.length,+ healthStatus:+ healthData.length > 0 ? "available" : "no-data",+ }),+ },+ ],+ },+ };+ }++ const projectProfileMatch = uri.match(+ /^agentmemory:\/\/project\/(.+)\/profile$/,+ );+ if (projectProfileMatch) {+ let projectName: string;+ try {+ projectName = decodeURIComponent(projectProfileMatch[1]);+ } catch {+ return {+ status_code: 400,+ body: { error: "Invalid percent-encoding in URI" },+ };+ }+ const profile = await sdk.trigger("mem::profile", {+ project: projectName,+ });+ return {+ status_code: 200,+ body: {+ contents: [+ {+ uri,+ mimeType: "application/json",+ text: JSON.stringify(profile),+ },+ ],+ },+ };+ }++ const projectRecentMatch = uri.match(+ /^agentmemory:\/\/project\/(.+)\/recent$/,+ );+ if (projectRecentMatch) {+ let projectName: string;+ try {+ projectName = decodeURIComponent(projectRecentMatch[1]);+ } catch {+ return {+ status_code: 400,+ body: { error: "Invalid percent-encoding in URI" },+ };+ }+ const summaries = await kv.list<SessionSummary>(KV.summaries);+ const filtered = summaries+ .filter((s) => s.project === projectName)+ .sort(+ (a, b) =>+ new Date(b.createdAt).getTime() -+ new Date(a.createdAt).getTime(),+ )+ .slice(0, 5);+ return {+ status_code: 200,+ body: {+ contents: [+ {+ uri,+ mimeType: "application/json",+ text: JSON.stringify(filtered),+ },+ ],+ },+ };+ }++ if (uri === "agentmemory://memories/latest") {+ const memories = await kv.list<Memory>(KV.memories);+ const latest = memories+ .filter((m) => m.isLatest)+ .sort(+ (a, b) =>+ new Date(b.updatedAt).getTime() -+ new Date(a.updatedAt).getTime(),+ )+ .slice(0, 10)+ .map((m) => ({+ id: m.id,+ title: m.title,+ type: m.type,+ strength: m.strength,+ }));+ return {+ status_code: 200,+ body: {+ contents: [+ {+ uri,+ mimeType: "application/json",+ text: JSON.stringify(latest),+ },+ ],+ },+ };+ }++ return {+ status_code: 404,+ body: { error: `Unknown resource: ${uri}` },+ };+ } catch {+ return { status_code: 500, body: { error: "Internal error" } };+ }+ },+ );+ sdk.registerTrigger({+ type: "http",+ function_id: "mcp::resources::read",+ config: {+ api_path: "/agentmemory/mcp/resources/read",+ http_method: "POST",+ },+ });++ const MCP_PROMPTS = [+ {+ name: "recall_context",+ description:+ "Search observations and memories to build context for a task",+ arguments: [+ {+ name: "task_description",+ description: "What you are working on",+ required: true,+ },+ ],+ },+ {+ name: "session_handoff",+ description:+ "Generate a handoff summary for continuing work in a new session",+ arguments: [+ {+ name: "session_id",+ description: "Session ID to hand off from",+ required: true,+ },+ ],+ },+ {+ name: "detect_patterns",+ description: "Detect recurring patterns across sessions for a project",+ arguments: [+ {+ name: "project",+ description: "Project path to analyze (optional)",+ required: false,+ },+ ],+ },+ ];++ sdk.registerFunction(+ { id: "mcp::prompts::list" },+ async (req: ApiRequest): Promise<McpResponse> => {+ const authErr = checkAuth(req, secret);+ if (authErr) return authErr;+ return { status_code: 200, body: { prompts: MCP_PROMPTS } };+ },+ );+ sdk.registerTrigger({+ type: "http",+ function_id: "mcp::prompts::list",+ config: { api_path: "/agentmemory/mcp/prompts", http_method: "GET" },+ });++ sdk.registerFunction(+ { id: "mcp::prompts::get" },+ async (+ req: ApiRequest<{ name: string; arguments?: Record<string, string> }>,+ ): Promise<McpResponse> => {+ const authErr = checkAuth(req, secret);+ if (authErr) return authErr;++ const promptName = req.body?.name;+ if (!promptName || typeof promptName !== "string") {+ return { status_code: 400, body: { error: "name is required" } };+ }++ const promptArgs = req.body?.arguments || {};++ try {+ switch (promptName) {+ case "recall_context": {+ const taskDesc = promptArgs.task_description;+ if (typeof taskDesc !== "string" || !taskDesc.trim()) {+ return {+ status_code: 400,+ body: {+ error:+ "task_description argument is required and must be a string",+ },+ };+ }+ const searchResult = await sdk+ .trigger("mem::search", { query: taskDesc, limit: 10 })+ .catch(() => ({ results: [] }));+ const memories = await kv.list<Memory>(KV.memories);+ const relevant = memories.filter((m) => m.isLatest).slice(0, 5);+ return {+ status_code: 200,+ body: {+ messages: [+ {+ role: "user",+ content: {+ type: "text",+ text: `Here is relevant context from past sessions for the task: "${taskDesc}"\n\n## Past Observations\n${JSON.stringify(searchResult, null, 2)}\n\n## Relevant Memories\n${JSON.stringify(relevant, null, 2)}`,+ },+ },+ ],+ },+ };+ }++ case "session_handoff": {+ const sessionId = promptArgs.session_id;+ if (typeof sessionId !== "string" || !sessionId.trim()) {+ return {+ status_code: 400,+ body: {+ error: "session_id argument is required and must be a string",+ },+ };+ }+ const session = await kv.get<Session>(KV.sessions, sessionId);+ const summaries = await kv.list<SessionSummary>(KV.summaries);+ const summary = summaries.find((s) => s.sessionId === sessionId);+ return {+ status_code: 200,+ body: {+ messages: [+ {+ role: "user",+ content: {+ type: "text",+ text: `## Session Handoff\n\n### Session\n${JSON.stringify(session, null, 2)}\n\n### Summary\n${JSON.stringify(summary || "No summary available", null, 2)}`,+ },+ },+ ],+ },+ };+ }++ case "detect_patterns": {+ if (+ promptArgs.project !== undefined &&+ typeof promptArgs.project !== "string"+ ) {+ return {+ status_code: 400,+ body: { error: "project argument must be a string" },+ };+ }+ const result = await sdk.trigger("mem::patterns", {+ project: promptArgs.project || undefined,+ });+ return {+ status_code: 200,+ body: {+ messages: [+ {+ role: "user",+ content: {+ type: "text",+ text: `## Pattern Analysis\n\n${JSON.stringify(result, null, 2)}`,+ },+ },+ ],+ },+ };+ }++ default:+ return {+ status_code: 400,+ body: { error: `Unknown prompt: ${promptName}` },+ };+ }+ } catch {+ return { status_code: 500, body: { error: "Internal error" } };+ }+ },+ );+ sdk.registerTrigger({+ type: "http",+ function_id: "mcp::prompts::get",+ config: { api_path: "/agentmemory/mcp/prompts/get", http_method: "POST" },+ });}diff --git a/src/triggers/api.ts b/src/triggers/api.tsindex 3d555d83..2bdd1cbf 100644--- a/src/triggers/api.ts+++ b/src/triggers/api.ts@@ -69,7 +69,7 @@ export function registerApiTriggers(body: {status,service: "agentmemory",- version: "0.3.0",+ version: "0.4.0",health: health || null,functionMetrics,circuitBreaker,@@ -254,6 +254,52 @@ export function registerApiTriggers(config: { api_path: "/agentmemory/file-context", http_method: "POST" },});+ sdk.registerFunction(+ { id: "api::enrich" },+ async (+ req: ApiRequest<{+ sessionId: string;+ files: string[];+ terms?: string[];+ toolName?: string;+ }>,+ ): Promise<Response> => {+ const authErr = checkAuth(req, secret);+ if (authErr) return authErr;+ if (+ !req.body?.sessionId ||+ typeof req.body.sessionId !== "string" ||+ !Array.isArray(req.body?.files) ||+ req.body.files.length === 0 ||+ !req.body.files.every((f: unknown) => typeof f === "string")+ ) {+ return {+ status_code: 400,+ body: {+ error: "sessionId (string) and files (string[]) are required",+ },+ };+ }+ if (+ req.body.terms !== undefined &&+ (!Array.isArray(req.body.terms) ||+ !req.body.terms.every((t: unknown) => typeof t === "string"))+ ) {+ return {+ status_code: 400,+ body: { error: "terms must be an array of strings" },+ };+ }+ const result = await sdk.trigger("mem::enrich", req.body);+ return { status_code: 200, body: result };+ },+ );+ sdk.registerTrigger({+ type: "http",+ function_id: "api::enrich",+ config: { api_path: "/agentmemory/enrich", http_method: "POST" },+ });+sdk.registerFunction({ id: "api::remember" },async (diff --git a/src/types.ts b/src/types.tsindex ca7402d2..f9ce7bc9 100644--- a/src/types.ts+++ b/src/types.ts@@ -197,6 +197,7 @@ export interface MemoryRelation {sourceId: string;targetId: string;createdAt: string;+ confidence?: number;}export interface HybridSearchResult {diff --git a/test/confidence.test.ts b/test/confidence.test.tsnew file mode 100644index 00000000..a3c62635--- /dev/null+++ b/test/confidence.test.ts@@ -0,0 +1,247 @@+import { describe, it, expect, beforeEach, vi } from "vitest";++vi.mock("iii-sdk", () => ({+ getContext: () => ({+ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },+ }),+}));++import { registerRelationsFunction } from "../src/functions/relations.js";+import type { Memory, MemoryRelation } from "../src/types.js";++function mockKV() {+ const store = new Map<string, Map<string, unknown>>();+ return {+ get: async <T>(scope: string, key: string): Promise<T | null> => {+ return (store.get(scope)?.get(key) as T) ?? null;+ },+ set: async <T>(scope: string, key: string, data: T): Promise<T> => {+ if (!store.has(scope)) store.set(scope, new Map());+ store.get(scope)!.set(key, data);+ return data;+ },+ delete: async (scope: string, key: string): Promise<void> => {+ store.get(scope)?.delete(key);+ },+ list: async <T>(scope: string): Promise<T[]> => {+ const entries = store.get(scope);+ return entries ? (Array.from(entries.values()) as T[]) : [];+ },+ };+}++function mockSdk() {+ const functions = new Map<string, Function>();+ return {+ registerFunction: (opts: { id: string }, handler: Function) => {+ functions.set(opts.id, handler);+ },+ registerTrigger: () => {},+ trigger: async (id: string, data: unknown) => {+ const fn = functions.get(id);+ if (!fn) throw new Error(`No function: ${id}`);+ return fn(data);+ },+ getFunction: (id: string) => functions.get(id),+ };+}++function makeMemory(overrides: Partial<Memory> = {}): Memory {+ return {+ id: "mem_1",+ createdAt: new Date().toISOString(),+ updatedAt: new Date().toISOString(),+ type: "pattern",+ title: "Test memory",+ content: "This is a test memory",+ concepts: ["test"],+ files: [],+ sessionIds: ["ses_1"],+ strength: 5,+ version: 1,+ isLatest: true,+ ...overrides,+ };+}++describe("Confidence Scoring", () => {+ let sdk: ReturnType<typeof mockSdk>;+ let kv: ReturnType<typeof mockKV>;++ beforeEach(() => {+ sdk = mockSdk();+ kv = mockKV();+ registerRelationsFunction(sdk as never, kv as never);+ });++ it("computes default confidence from co-occurrence and recency", async () => {+ const mem1 = makeMemory({+ id: "mem_1",+ sessionIds: ["ses_1", "ses_2"],+ updatedAt: new Date().toISOString(),+ });+ const mem2 = makeMemory({+ id: "mem_2",+ sessionIds: ["ses_1", "ses_2", "ses_3"],+ updatedAt: new Date().toISOString(),+ });+ await kv.set("mem:memories", "mem_1", mem1);+ await kv.set("mem:memories", "mem_2", mem2);++ const result = (await sdk.trigger("mem::relate", {+ sourceId: "mem_1",+ targetId: "mem_2",+ type: "related",+ })) as { success: boolean; relation: MemoryRelation };++ expect(result.success).toBe(true);+ expect(result.relation.confidence).toBeGreaterThan(0.5);+ expect(result.relation.confidence).toBeLessThanOrEqual(1);+ });++ it("uses explicit confidence when provided", async () => {+ const mem1 = makeMemory({ id: "mem_1" });+ const mem2 = makeMemory({ id: "mem_2" });+ await kv.set("mem:memories", "mem_1", mem1);+ await kv.set("mem:memories", "mem_2", mem2);++ const result = (await sdk.trigger("mem::relate", {+ sourceId: "mem_1",+ targetId: "mem_2",+ type: "related",+ confidence: 0.95,+ })) as { success: boolean; relation: MemoryRelation };++ expect(result.relation.confidence).toBe(0.95);+ });++ it("clamps confidence to [0, 1]", async () => {+ const mem1 = makeMemory({ id: "mem_1" });+ const mem2 = makeMemory({ id: "mem_2" });+ await kv.set("mem:memories", "mem_1", mem1);+ await kv.set("mem:memories", "mem_2", mem2);++ const over = (await sdk.trigger("mem::relate", {+ sourceId: "mem_1",+ targetId: "mem_2",+ type: "related",+ confidence: 1.5,+ })) as { success: boolean; relation: MemoryRelation };+ expect(over.relation.confidence).toBe(1);++ const mem3 = makeMemory({ id: "mem_3" });+ await kv.set("mem:memories", "mem_3", mem3);++ const under = (await sdk.trigger("mem::relate", {+ sourceId: "mem_1",+ targetId: "mem_3",+ type: "related",+ confidence: -0.5,+ })) as { success: boolean; relation: MemoryRelation };+ expect(under.relation.confidence).toBe(0);+ });++ it("mem::get-related sorts by confidence desc", async () => {+ const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2", "mem_3"] });+ const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1"] });+ const mem3 = makeMemory({ id: "mem_3", relatedIds: ["mem_1"] });+ await kv.set("mem:memories", "mem_1", mem1);+ await kv.set("mem:memories", "mem_2", mem2);+ await kv.set("mem:memories", "mem_3", mem3);++ await kv.set("mem:relations", "rel_low", {+ type: "related",+ sourceId: "mem_1",+ targetId: "mem_2",+ createdAt: new Date().toISOString(),+ confidence: 0.3,+ } as MemoryRelation);+ await kv.set("mem:relations", "rel_high", {+ type: "related",+ sourceId: "mem_1",+ targetId: "mem_3",+ createdAt: new Date().toISOString(),+ confidence: 0.9,+ } as MemoryRelation);++ const result = (await sdk.trigger("mem::get-related", {+ memoryId: "mem_1",+ maxHops: 1,+ })) as { results: Array<{ memory: Memory; hop: number; confidence: number }> };++ expect(result.results.length).toBe(2);+ expect(result.results[0].confidence).toBeGreaterThanOrEqual(+ result.results[1].confidence,+ );+ });++ it("minConfidence filter works", async () => {+ const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2", "mem_3"] });+ const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1"] });+ const mem3 = makeMemory({ id: "mem_3", relatedIds: ["mem_1"] });+ await kv.set("mem:memories", "mem_1", mem1);+ await kv.set("mem:memories", "mem_2", mem2);+ await kv.set("mem:memories", "mem_3", mem3);++ await kv.set("mem:relations", "rel_low", {+ type: "related",+ sourceId: "mem_1",+ targetId: "mem_2",+ createdAt: new Date().toISOString(),+ confidence: 0.2,+ } as MemoryRelation);+ await kv.set("mem:relations", "rel_high", {+ type: "related",+ sourceId: "mem_1",+ targetId: "mem_3",+ createdAt: new Date().toISOString(),+ confidence: 0.8,+ } as MemoryRelation);++ const result = (await sdk.trigger("mem::get-related", {+ memoryId: "mem_1",+ maxHops: 1,+ minConfidence: 0.5,+ })) as { results: Array<{ memory: Memory; hop: number; confidence: number }> };++ expect(result.results.length).toBe(1);+ expect(result.results[0].memory.id).toBe("mem_3");+ });++ it("mem::evolve creates supersedes relation with confidence=1.0", async () => {+ const original = makeMemory({ id: "mem_old", version: 1 });+ await kv.set("mem:memories", "mem_old", original);++ await sdk.trigger("mem::evolve", {+ memoryId: "mem_old",+ newContent: "Updated content",+ });++ const relations = await kv.list<MemoryRelation>("mem:relations");+ const supersedesRel = relations.find((r) => r.type === "supersedes");+ expect(supersedesRel).toBeDefined();+ expect(supersedesRel!.confidence).toBe(1.0);+ });++ it("old relations without confidence default to 0.5", async () => {+ const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2"] });+ const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1"] });+ await kv.set("mem:memories", "mem_1", mem1);+ await kv.set("mem:memories", "mem_2", mem2);++ await kv.set("mem:relations", "rel_old", {+ type: "related",+ sourceId: "mem_1",+ targetId: "mem_2",+ createdAt: new Date().toISOString(),+ } as MemoryRelation);++ const result = (await sdk.trigger("mem::get-related", {+ memoryId: "mem_1",+ maxHops: 1,+ })) as { results: Array<{ memory: Memory; hop: number; confidence: number }> };++ expect(result.results.length).toBe(1);+ expect(result.results[0].confidence).toBe(0.5);+ });+});diff --git a/test/enrich.test.ts b/test/enrich.test.tsnew file mode 100644index 00000000..2e8498d8--- /dev/null+++ b/test/enrich.test.ts@@ -0,0 +1,209 @@+import { describe, it, expect, beforeEach, vi } from "vitest";++vi.mock("iii-sdk", () => ({+ getContext: () => ({+ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },+ }),+}));++import { registerEnrichFunction } from "../src/functions/enrich.js";+import type { Memory } from "../src/types.js";++function mockKV() {+ const store = new Map<string, Map<string, unknown>>();+ return {+ get: async <T>(scope: string, key: string): Promise<T | null> => {+ return (store.get(scope)?.get(key) as T) ?? null;+ },+ set: async <T>(scope: string, key: string, data: T): Promise<T> => {+ if (!store.has(scope)) store.set(scope, new Map());+ store.get(scope)!.set(key, data);+ return data;+ },+ delete: async (scope: string, key: string): Promise<void> => {+ store.get(scope)?.delete(key);+ },+ list: async <T>(scope: string): Promise<T[]> => {+ const entries = store.get(scope);+ return entries ? (Array.from(entries.values()) as T[]) : [];+ },+ };+}++function makeMemory(overrides: Partial<Memory> = {}): Memory {+ return {+ id: "mem_1",+ createdAt: new Date().toISOString(),+ updatedAt: new Date().toISOString(),+ type: "bug",+ title: "Known bug",+ content: "Null pointer in handler",+ concepts: ["bug"],+ files: ["src/handler.ts"],+ sessionIds: ["ses_1"],+ strength: 5,+ version: 1,+ isLatest: true,+ ...overrides,+ };+}++function mockSdk() {+ const functions = new Map<string, Function>();+ const triggerOverrides = new Map<string, Function>();+ return {+ registerFunction: (opts: { id: string }, handler: Function) => {+ functions.set(opts.id, handler);+ },+ registerTrigger: () => {},+ trigger: async (id: string, data: unknown) => {+ if (triggerOverrides.has(id)) {+ return triggerOverrides.get(id)!(data);+ }+ const fn = functions.get(id);+ if (!fn) throw new Error(`No function: ${id}`);+ return fn(data);+ },+ overrideTrigger: (id: string, handler: Function) => {+ triggerOverrides.set(id, handler);+ },+ getFunction: (id: string) => functions.get(id),+ };+}++describe("Enrich Function", () => {+ let sdk: ReturnType<typeof mockSdk>;+ let kv: ReturnType<typeof mockKV>;++ beforeEach(() => {+ sdk = mockSdk();+ kv = mockKV();+ registerEnrichFunction(sdk as never, kv as never);+ });++ it("returns file context and relevant memories", async () => {+ sdk.overrideTrigger(+ "mem::file-context",+ async () => ({ context: "File was edited in session ses_1" }),+ );+ sdk.overrideTrigger("mem::search", async () => ({+ results: [+ { observation: { narrative: "User fixed a bug in handler" } },+ ],+ }));++ const bugMem = makeMemory({+ id: "bug_1",+ files: ["src/handler.ts"],+ type: "bug",+ });+ await kv.set("mem:memories", "bug_1", bugMem);++ const result = (await sdk.trigger("mem::enrich", {+ sessionId: "ses_1",+ files: ["src/handler.ts"],+ })) as { context: string; truncated: boolean };++ expect(result.context).toContain("File was edited in session ses_1");+ expect(result.context).toContain("agentmemory-relevant-context");+ expect(result.context).toContain("agentmemory-past-errors");+ expect(result.truncated).toBe(false);+ });++ it("extracts terms from Grep/Glob pattern for search", async () => {+ let capturedQuery = "";+ sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));+ sdk.overrideTrigger("mem::search", async (data: any) => {+ capturedQuery = data.query;+ return { results: [] };+ });++ await sdk.trigger("mem::enrich", {+ sessionId: "ses_1",+ files: ["src/utils.ts"],+ terms: ["handleError"],+ toolName: "Grep",+ });++ expect(capturedQuery).toContain("handleError");+ });++ it("truncates context at 4000 chars", async () => {+ const longContext = "x".repeat(5000);+ sdk.overrideTrigger(+ "mem::file-context",+ async () => ({ context: longContext }),+ );+ sdk.overrideTrigger("mem::search", async () => ({ results: [] }));++ const result = (await sdk.trigger("mem::enrich", {+ sessionId: "ses_1",+ files: ["src/big.ts"],+ })) as { context: string; truncated: boolean };++ expect(result.context.length).toBe(4000);+ expect(result.truncated).toBe(true);+ });++ it("returns empty context when no data found", async () => {+ sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));+ sdk.overrideTrigger("mem::search", async () => ({ results: [] }));++ const result = (await sdk.trigger("mem::enrich", {+ sessionId: "ses_1",+ files: ["src/new-file.ts"],+ })) as { context: string; truncated: boolean };++ expect(result.context).toBe("");+ expect(result.truncated).toBe(false);+ });++ it("handles failed triggers without crashing", async () => {+ sdk.overrideTrigger("mem::file-context", async () => {+ throw new Error("file-context failed");+ });+ sdk.overrideTrigger("mem::search", async () => {+ throw new Error("search failed");+ });++ const result = (await sdk.trigger("mem::enrich", {+ sessionId: "ses_1",+ files: ["src/handler.ts"],+ })) as { context: string; truncated: boolean };++ expect(result.context).toBeDefined();+ expect(result.truncated).toBe(false);+ });++ it("includes bug memories that overlap with requested files", async () => {+ sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));+ sdk.overrideTrigger("mem::search", async () => ({ results: [] }));++ const bugMem = makeMemory({+ id: "bug_match",+ type: "bug",+ title: "Race condition",+ content: "Race condition in worker pool",+ files: ["src/worker.ts"],+ isLatest: true,+ });+ const nonBugMem = makeMemory({+ id: "pattern_1",+ type: "pattern",+ title: "Code pattern",+ content: "Singleton pattern used",+ files: ["src/worker.ts"],+ isLatest: true,+ });+ await kv.set("mem:memories", "bug_match", bugMem);+ await kv.set("mem:memories", "pattern_1", nonBugMem);++ const result = (await sdk.trigger("mem::enrich", {+ sessionId: "ses_1",+ files: ["src/worker.ts"],+ })) as { context: string; truncated: boolean };++ expect(result.context).toContain("Race condition");+ expect(result.context).not.toContain("Singleton pattern");+ });+});diff --git a/test/mcp-prompts.test.ts b/test/mcp-prompts.test.tsnew file mode 100644index 00000000..903e90d1--- /dev/null+++ b/test/mcp-prompts.test.ts@@ -0,0 +1,218 @@+import { describe, it, expect, beforeEach, vi } from "vitest";++vi.mock("iii-sdk", () => ({+ getContext: () => ({+ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },+ }),+}));++import { registerMcpEndpoints } from "../src/mcp/server.js";+import type { Session, SessionSummary, Memory } from "../src/types.js";++function mockKV() {+ const store = new Map<string, Map<string, unknown>>();+ return {+ get: async <T>(scope: string, key: string): Promise<T | null> => {+ return (store.get(scope)?.get(key) as T) ?? null;+ },+ set: async <T>(scope: string, key: string, data: T): Promise<T> => {+ if (!store.has(scope)) store.set(scope, new Map());+ store.get(scope)!.set(key, data);+ return data;+ },+ delete: async (scope: string, key: string): Promise<void> => {+ store.get(scope)?.delete(key);+ },+ list: async <T>(scope: string): Promise<T[]> => {+ const entries = store.get(scope);+ return entries ? (Array.from(entries.values()) as T[]) : [];+ },+ };+}++function mockSdk() {+ const functions = new Map<string, Function>();+ const triggerOverrides = new Map<string, Function>();+ return {+ registerFunction: (opts: { id: string }, handler: Function) => {+ functions.set(opts.id, handler);+ },+ registerTrigger: () => {},+ trigger: async (id: string, data: unknown) => {+ if (triggerOverrides.has(id)) {+ return triggerOverrides.get(id)!(data);+ }+ const fn = functions.get(id);+ if (!fn) throw new Error(`No function: ${id}`);+ return fn(data);+ },+ overrideTrigger: (id: string, handler: Function) => {+ triggerOverrides.set(id, handler);+ },+ getFunction: (id: string) => functions.get(id),+ };+}++function makeReq(body?: unknown, headers?: Record<string, string>) {+ return {+ body,+ headers: headers || {},+ query_params: {},+ };+}++describe("MCP Prompts", () => {+ let sdk: ReturnType<typeof mockSdk>;+ let kv: ReturnType<typeof mockKV>;++ beforeEach(() => {+ sdk = mockSdk();+ kv = mockKV();+ registerMcpEndpoints(sdk as never, kv as never);+ });++ it("lists 3 prompts", async () => {+ const fn = sdk.getFunction("mcp::prompts::list")!;+ const result = (await fn(makeReq())) as {+ status_code: number;+ body: { prompts: unknown[] };+ };++ expect(result.status_code).toBe(200);+ expect(result.body.prompts).toHaveLength(3);+ });++ it("recall_context returns messages with search results", async () => {+ sdk.overrideTrigger("mem::search", async () => ({+ results: [{ observation: { title: "Found something" } }],+ }));++ const mem: Memory = {+ id: "mem_1",+ createdAt: new Date().toISOString(),+ updatedAt: new Date().toISOString(),+ type: "pattern",+ title: "Auth pattern",+ content: "Always use JWT",+ concepts: ["auth"],+ files: [],+ sessionIds: [],+ strength: 5,+ version: 1,+ isLatest: true,+ };+ await kv.set("mem:memories", "mem_1", mem);++ const fn = sdk.getFunction("mcp::prompts::get")!;+ const result = (await fn(+ makeReq({+ name: "recall_context",+ arguments: { task_description: "implement auth" },+ }),+ )) as {+ status_code: number;+ body: { messages: Array<{ role: string; content: { text: string } }> };+ };++ expect(result.status_code).toBe(200);+ expect(result.body.messages).toHaveLength(1);+ expect(result.body.messages[0].role).toBe("user");+ expect(result.body.messages[0].content.text).toContain("implement auth");+ });++ it("session_handoff returns session data", async () => {+ const session: Session = {+ id: "ses_1",+ project: "/test",+ cwd: "/test",+ startedAt: "2026-02-01T00:00:00Z",+ status: "completed",+ observationCount: 10,+ };+ await kv.set("mem:sessions", "ses_1", session);++ const summary: SessionSummary = {+ sessionId: "ses_1",+ project: "/test",+ createdAt: "2026-02-01T00:00:00Z",+ title: "Auth implementation",+ narrative: "Implemented JWT auth",+ keyDecisions: ["Used JWT"],+ filesModified: ["src/auth.ts"],+ concepts: ["auth"],+ observationCount: 10,+ };+ await kv.set("mem:summaries", "ses_1", summary);++ const fn = sdk.getFunction("mcp::prompts::get")!;+ const result = (await fn(+ makeReq({+ name: "session_handoff",+ arguments: { session_id: "ses_1" },+ }),+ )) as {+ status_code: number;+ body: { messages: Array<{ role: string; content: { text: string } }> };+ };++ expect(result.status_code).toBe(200);+ expect(result.body.messages[0].content.text).toContain("Session Handoff");+ expect(result.body.messages[0].content.text).toContain("ses_1");+ });++ it("detect_patterns returns analysis", async () => {+ sdk.overrideTrigger("mem::patterns", async () => ({+ fileCoOccurrence: [{ files: ["a.ts", "b.ts"], count: 5 }],+ }));++ const fn = sdk.getFunction("mcp::prompts::get")!;+ const result = (await fn(+ makeReq({+ name: "detect_patterns",+ arguments: { project: "/myapp" },+ }),+ )) as {+ status_code: number;+ body: { messages: Array<{ role: string; content: { text: string } }> };+ };++ expect(result.status_code).toBe(200);+ expect(result.body.messages[0].content.text).toContain("Pattern Analysis");+ });++ it("returns 400 for missing required arg", async () => {+ const fn = sdk.getFunction("mcp::prompts::get")!;+ const result = (await fn(+ makeReq({+ name: "recall_context",+ arguments: {},+ }),+ )) as { status_code: number };++ expect(result.status_code).toBe(400);+ });++ it("returns 400 for unknown prompt name", async () => {+ const fn = sdk.getFunction("mcp::prompts::get")!;+ const result = (await fn(+ makeReq({+ name: "nonexistent_prompt",+ arguments: {},+ }),+ )) as { status_code: number };++ expect(result.status_code).toBe(400);+ });++ it("returns 400 for non-string argument value", async () => {+ const fn = sdk.getFunction("mcp::prompts::get")!;+ const result = (await fn(+ makeReq({+ name: "recall_context",+ arguments: { task_description: 42 },+ }),+ )) as { status_code: number };++ expect(result.status_code).toBe(400);+ });+});diff --git a/test/mcp-resources.test.ts b/test/mcp-resources.test.tsnew file mode 100644index 00000000..c4e1183f--- /dev/null+++ b/test/mcp-resources.test.ts@@ -0,0 +1,286 @@+import { describe, it, expect, beforeEach, vi } from "vitest";++vi.mock("iii-sdk", () => ({+ getContext: () => ({+ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },+ }),+}));++import { registerMcpEndpoints } from "../src/mcp/server.js";+import type { Session, SessionSummary, Memory } from "../src/types.js";++function mockKV() {+ const store = new Map<string, Map<string, unknown>>();+ return {+ get: async <T>(scope: string, key: string): Promise<T | null> => {+ return (store.get(scope)?.get(key) as T) ?? null;+ },+ set: async <T>(scope: string, key: string, data: T): Promise<T> => {+ if (!store.has(scope)) store.set(scope, new Map());+ store.get(scope)!.set(key, data);+ return data;+ },+ delete: async (scope: string, key: string): Promise<void> => {+ store.get(scope)?.delete(key);+ },+ list: async <T>(scope: string): Promise<T[]> => {+ const entries = store.get(scope);+ return entries ? (Array.from(entries.values()) as T[]) : [];+ },+ };+}++function mockSdk() {+ const functions = new Map<string, Function>();+ const triggerOverrides = new Map<string, Function>();+ return {+ registerFunction: (opts: { id: string }, handler: Function) => {+ functions.set(opts.id, handler);+ },+ registerTrigger: () => {},+ trigger: async (id: string, data: unknown) => {+ if (triggerOverrides.has(id)) {+ return triggerOverrides.get(id)!(data);+ }+ const fn = functions.get(id);+ if (!fn) throw new Error(`No function: ${id}`);+ return fn(data);+ },+ overrideTrigger: (id: string, handler: Function) => {+ triggerOverrides.set(id, handler);+ },+ getFunction: (id: string) => functions.get(id),+ };+}++function makeReq(body?: unknown, headers?: Record<string, string>) {+ return {+ body,+ headers: headers || {},+ query_params: {},+ };+}++describe("MCP Resources", () => {+ let sdk: ReturnType<typeof mockSdk>;+ let kv: ReturnType<typeof mockKV>;++ beforeEach(() => {+ sdk = mockSdk();+ kv = mockKV();+ registerMcpEndpoints(sdk as never, kv as never);+ });++ it("lists 4 resources", async () => {+ const fn = sdk.getFunction("mcp::resources::list")!;+ const result = (await fn(makeReq())) as {+ status_code: number;+ body: { resources: unknown[] };+ };++ expect(result.status_code).toBe(200);+ expect(result.body.resources).toHaveLength(4);+ });++ it("reads agentmemory://status", async () => {+ const session: Session = {+ id: "ses_1",+ project: "/test",+ cwd: "/test",+ startedAt: new Date().toISOString(),+ status: "active",+ observationCount: 5,+ };+ await kv.set("mem:sessions", "ses_1", session);++ const fn = sdk.getFunction("mcp::resources::read")!;+ const result = (await fn(makeReq({ uri: "agentmemory://status" }))) as {+ status_code: number;+ body: { contents: Array<{ text: string }> };+ };++ expect(result.status_code).toBe(200);+ const data = JSON.parse(result.body.contents[0].text);+ expect(data.sessionCount).toBe(1);+ });++ it("reads agentmemory://project/{name}/profile", async () => {+ sdk.overrideTrigger("mem::profile", async () => ({+ project: "/myapp",+ topConcepts: [{ concept: "auth", frequency: 5 }],+ }));++ const fn = sdk.getFunction("mcp::resources::read")!;+ const result = (await fn(+ makeReq({ uri: "agentmemory://project/myapp/profile" }),+ )) as {+ status_code: number;+ body: { contents: Array<{ text: string }> };+ };++ expect(result.status_code).toBe(200);+ const data = JSON.parse(result.body.contents[0].text);+ expect(data.project).toBe("/myapp");+ });++ it("reads agentmemory://project/{name}/recent with sorted summaries", async () => {+ const summaries: SessionSummary[] = [+ {+ sessionId: "ses_1",+ project: "myapp",+ createdAt: "2026-01-01T00:00:00Z",+ title: "Old session",+ narrative: "old",+ keyDecisions: [],+ filesModified: [],+ concepts: [],+ observationCount: 1,+ },+ {+ sessionId: "ses_2",+ project: "myapp",+ createdAt: "2026-02-01T00:00:00Z",+ title: "New session",+ narrative: "new",+ keyDecisions: [],+ filesModified: [],+ concepts: [],+ observationCount: 2,+ },+ {+ sessionId: "ses_3",+ project: "other",+ createdAt: "2026-02-15T00:00:00Z",+ title: "Other project",+ narrative: "other",+ keyDecisions: [],+ filesModified: [],+ concepts: [],+ observationCount: 3,+ },+ ];+ for (const s of summaries) {+ await kv.set("mem:summaries", s.sessionId, s);+ }++ const fn = sdk.getFunction("mcp::resources::read")!;+ const result = (await fn(+ makeReq({ uri: "agentmemory://project/myapp/recent" }),+ )) as {+ status_code: number;+ body: { contents: Array<{ text: string }> };+ };++ expect(result.status_code).toBe(200);+ const data = JSON.parse(result.body.contents[0].text);+ expect(data).toHaveLength(2);+ expect(data[0].sessionId).toBe("ses_2");+ });++ it("reads agentmemory://memories/latest", async () => {+ const memories: Memory[] = [+ {+ id: "mem_1",+ createdAt: "2026-01-01T00:00:00Z",+ updatedAt: "2026-02-01T00:00:00Z",+ type: "pattern",+ title: "Latest pattern",+ content: "content",+ concepts: [],+ files: [],+ sessionIds: [],+ strength: 5,+ version: 1,+ isLatest: true,+ },+ {+ id: "mem_2",+ createdAt: "2026-01-01T00:00:00Z",+ updatedAt: "2026-01-15T00:00:00Z",+ type: "bug",+ title: "Old bug",+ content: "content",+ concepts: [],+ files: [],+ sessionIds: [],+ strength: 3,+ version: 2,+ isLatest: false,+ },+ ];+ for (const m of memories) {+ await kv.set("mem:memories", m.id, m);+ }++ const fn = sdk.getFunction("mcp::resources::read")!;+ const result = (await fn(+ makeReq({ uri: "agentmemory://memories/latest" }),+ )) as {+ status_code: number;+ body: { contents: Array<{ text: string }> };+ };++ expect(result.status_code).toBe(200);+ const data = JSON.parse(result.body.contents[0].text);+ expect(data).toHaveLength(1);+ expect(data[0].id).toBe("mem_1");+ expect(data[0].title).toBe("Latest pattern");+ });++ it("returns 404 for unknown URI", async () => {+ const fn = sdk.getFunction("mcp::resources::read")!;+ const result = (await fn(+ makeReq({ uri: "agentmemory://nonexistent" }),+ )) as { status_code: number };++ expect(result.status_code).toBe(404);+ });++ it("returns 401 when auth fails", async () => {+ const authedSdk = mockSdk();+ const authedKv = mockKV();+ registerMcpEndpoints(authedSdk as never, authedKv as never, "test-secret");++ const fn = authedSdk.getFunction("mcp::resources::list")!;+ const result = (await fn(makeReq())) as { status_code: number };+ expect(result.status_code).toBe(401);++ const authedResult = (await fn(+ makeReq(undefined, { authorization: "Bearer test-secret" }),+ )) as { status_code: number };+ expect(authedResult.status_code).toBe(200);+ });++ it("handles URI with special characters via decodeURIComponent", async () => {+ sdk.overrideTrigger("mem::profile", async (data: any) => ({+ project: data.project,+ topConcepts: [],+ }));++ const fn = sdk.getFunction("mcp::resources::read")!;+ const result = (await fn(+ makeReq({+ uri: "agentmemory://project/my%20app%2Fsubdir/profile",+ }),+ )) as {+ status_code: number;+ body: { contents: Array<{ text: string }> };+ };++ expect(result.status_code).toBe(200);+ const data = JSON.parse(result.body.contents[0].text);+ expect(data.project).toBe("my app/subdir");+ });++ it("returns 400 for malformed percent-encoding in URI", async () => {+ const fn = sdk.getFunction("mcp::resources::read")!;+ const result = (await fn(+ makeReq({+ uri: "agentmemory://project/bad%E0encoding/profile",+ }),+ )) as { status_code: number; body: { error: string } };++ expect(result.status_code).toBe(400);+ expect(result.body.error).toContain("percent-encoding");+ });+});