@agentmemory/agentmemory 0.7.0

package/test/claude-bridge.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+vi.mock("node:fs", () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+}));
+
+vi.mock("node:path", async () => ({
+  ...(await vi.importActual("node:path")),
+  dirname: vi.fn().mockReturnValue("/tmp"),
+}));
+
+import { registerClaudeBridgeFunction } from "../src/functions/claude-bridge.js";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import type { ClaudeBridgeConfig, 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>();
+  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);
+    },
+  };
+}
+
+const enabledConfig: ClaudeBridgeConfig = {
+  enabled: true,
+  projectPath: "/tmp/my-project",
+  memoryFilePath: "/tmp/.claude/MEMORY.md",
+  lineBudget: 200,
+};
+
+const disabledConfig: ClaudeBridgeConfig = {
+  enabled: false,
+  projectPath: "",
+  memoryFilePath: "",
+  lineBudget: 200,
+};
+
+describe("Claude Bridge Functions", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+
+  beforeEach(() => {
+    sdk = mockSdk();
+    kv = mockKV();
+    vi.clearAllMocks();
+  });
+
+  it("claude-bridge-read returns content when file exists", async () => {
+    registerClaudeBridgeFunction(sdk as never, kv as never, enabledConfig);
+
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(
+      "# Memory\n\n## Project Summary\nA test project\n\n## Key Memories\nSome memories",
+    );
+
+    const result = (await sdk.trigger("mem::claude-bridge-read", {})) as {
+      success: boolean;
+      content: string;
+      sections: Record<string, string>;
+    };
+
+    expect(result.success).toBe(true);
+    expect(result.content).toContain("# Memory");
+    expect(result.sections).toBeDefined();
+    expect(result.sections["Project Summary"]).toBe("A test project");
+  });
+
+  it("claude-bridge-read returns empty when file does not exist", async () => {
+    registerClaudeBridgeFunction(sdk as never, kv as never, enabledConfig);
+
+    vi.mocked(existsSync).mockReturnValue(false);
+
+    const result = (await sdk.trigger("mem::claude-bridge-read", {})) as {
+      success: boolean;
+      content: string;
+      parsed: boolean;
+    };
+
+    expect(result.success).toBe(true);
+    expect(result.content).toBe("");
+    expect(result.parsed).toBe(false);
+  });
+
+  it("claude-bridge-sync writes MEMORY.md with memories", async () => {
+    registerClaudeBridgeFunction(sdk as never, kv as never, enabledConfig);
+
+    const mem: Memory = {
+      id: "mem_1",
+      createdAt: "2026-02-01T00:00:00Z",
+      updatedAt: "2026-02-01T00:00:00Z",
+      type: "pattern",
+      title: "Auth pattern",
+      content: "Always validate tokens",
+      concepts: ["auth"],
+      files: [],
+      sessionIds: ["ses_1"],
+      strength: 5,
+      version: 1,
+      isLatest: true,
+    };
+    await kv.set("mem:memories", "mem_1", mem);
+
+    vi.mocked(existsSync).mockReturnValue(true);
+
+    const result = (await sdk.trigger("mem::claude-bridge-sync", {})) as {
+      success: boolean;
+      path: string;
+      lines: number;
+    };
+
+    expect(result.success).toBe(true);
+    expect(result.path).toBe("/tmp/.claude/MEMORY.md");
+    expect(writeFileSync).toHaveBeenCalled();
+    const writtenContent = vi.mocked(writeFileSync).mock.calls[0][1] as string;
+    expect(writtenContent).toContain("Auth pattern");
+  });
+
+  it("claude-bridge-sync returns error when not configured", async () => {
+    registerClaudeBridgeFunction(sdk as never, kv as never, disabledConfig);
+
+    const result = (await sdk.trigger("mem::claude-bridge-sync", {})) as {
+      success: boolean;
+      error: string;
+    };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("not configured");
+  });
+
+  it("claude-bridge-read returns error when not configured", async () => {
+    registerClaudeBridgeFunction(sdk as never, kv as never, disabledConfig);
+
+    const result = (await sdk.trigger("mem::claude-bridge-read", {})) as {
+      success: boolean;
+      error: string;
+    };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("not configured");
+  });
+});

package/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);
+  });
+});

package/test/consistency.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi } from "vitest";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+import { getAllTools } from "../src/mcp/tools-registry.js";
+import { VERSION } from "../src/version.js";
+
+const ROOT = join(import.meta.dirname, "..");
+
+function readText(relativePath: string): string {
+  return readFileSync(join(ROOT, relativePath), "utf-8");
+}
+
+describe("Consistency checks", () => {
+  const toolCount = getAllTools().length;
+
+  it("version.ts matches package.json", () => {
+    const pkg = JSON.parse(readText("package.json"));
+    expect(VERSION).toBe(pkg.version);
+  });
+
+  it("plugin.json version matches package.json", () => {
+    const pkg = JSON.parse(readText("package.json"));
+    const plugin = JSON.parse(readText("plugin/.claude-plugin/plugin.json"));
+    expect(plugin.version).toBe(pkg.version);
+  });
+
+  it("export-import.ts supports current version", () => {
+    const src = readText("src/functions/export-import.ts");
+    expect(src).toContain(`"${VERSION}"`);
+  });
+
+  it("README mentions correct MCP tool count", () => {
+    const readme = readText("README.md");
+    const toolCountPattern = new RegExp(`${toolCount}\\s+MCP tools`);
+    expect(readme).toMatch(toolCountPattern);
+    const toolResourcePattern = new RegExp(`${toolCount}\\s+tools,\\s+6\\s+resources`);
+    expect(readme).toMatch(toolResourcePattern);
+  });
+
+  it("all tool names are unique", () => {
+    const tools = getAllTools();
+    const names = new Set(tools.map((t) => t.name));
+    expect(names.size).toBe(tools.length);
+  });
+
+  it("all tools have name, description, and inputSchema", () => {
+    for (const tool of getAllTools()) {
+      expect(tool.name).toBeTruthy();
+      expect(tool.description).toBeTruthy();
+      expect(tool.inputSchema).toBeDefined();
+      expect(tool.inputSchema.type).toBe("object");
+    }
+  });
+});