@agentmemory/agentmemory 0.7.2 → 0.7.3

package/test/claude-bridge.test.ts

@@ -1,178 +0,0 @@
-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

@@ -1,247 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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");
-    }
-  });
-});