@clawmem-ai/clawmem 0.1.16 → 0.1.17

package/src/github-client.ts

@@ -52,6 +52,12 @@ type RepositoryInvitationResponse = {
   inviter?: { login?: string; name?: string };
 };
 type TeamMembershipResponse = { state?: string; role?: string };
+type OrganizationMembershipResponse = {
+  state?: string;
+  role?: string;
+  organization?: OrgResponse;
+  user?: CollaboratorResponse;
+};
 type InvitationResponse = {
   id?: number;
   role?: string;
@@ -145,9 +151,30 @@ export class GitHubIssueClient {
   async getOrg(org: string): Promise<OrgResponse> {
     return this.req<OrgResponse>(`orgs/${encodeURIComponent(org)}`, { method: "GET" });
   }
+  async listOrgMembers(org: string, role?: "admin"): Promise<CollaboratorResponse[]> {
+    const q = new URLSearchParams();
+    if (role) q.set("role", role);
+    const suffix = q.toString();
+    return this.req<CollaboratorResponse[]>(`orgs/${encodeURIComponent(org)}/members${suffix ? `?${suffix}` : ""}`, { method: "GET" });
+  }
+  async getOrgMembership(org: string, username: string): Promise<OrganizationMembershipResponse> {
+    return this.req<OrganizationMembershipResponse>(
+      `orgs/${encodeURIComponent(org)}/memberships/${encodeURIComponent(username)}`,
+      { method: "GET" },
+    );
+  }
+  async removeOrgMember(org: string, username: string): Promise<void> {
+    await this.req(`orgs/${encodeURIComponent(org)}/members/${encodeURIComponent(username)}`, { method: "DELETE" });
+  }
+  async removeOrgMembership(org: string, username: string): Promise<void> {
+    await this.req(`orgs/${encodeURIComponent(org)}/memberships/${encodeURIComponent(username)}`, { method: "DELETE" });
+  }
   async listOrgTeams(org: string): Promise<TeamResponse[]> {
     return this.req<TeamResponse[]>(`orgs/${encodeURIComponent(org)}/teams`, { method: "GET" });
   }
+  async getTeam(org: string, teamSlug: string): Promise<TeamResponse> {
+    return this.req<TeamResponse>(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}`, { method: "GET" });
+  }
   async createOrgTeam(org: string, params: { name: string; description?: string; privacy?: "closed" | "secret" }): Promise<TeamResponse> {
     return this.req<TeamResponse>(`orgs/${encodeURIComponent(org)}/teams`, {
       method: "POST",
@@ -158,6 +185,29 @@ export class GitHubIssueClient {
       }),
     });
   }
+  async updateTeam(
+    org: string,
+    teamSlug: string,
+    params: { name?: string; description?: string; privacy?: "closed" | "secret" },
+  ): Promise<TeamResponse> {
+    return this.req<TeamResponse>(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        ...(params.name ? { name: params.name } : {}),
+        ...(params.description ? { description: params.description } : {}),
+        ...(params.privacy ? { privacy: params.privacy } : {}),
+      }),
+    });
+  }
+  async deleteTeam(org: string, teamSlug: string): Promise<void> {
+    await this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}`, { method: "DELETE" });
+  }
+  async listTeamMembers(org: string, teamSlug: string): Promise<CollaboratorResponse[]> {
+    return this.req<CollaboratorResponse[]>(
+      `orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/members`,
+      { method: "GET" },
+    );
+  }
   async setTeamMembership(org: string, teamSlug: string, username: string, role: "member" | "maintainer"): Promise<TeamMembershipResponse> {
     return this.req<TeamMembershipResponse>(
       `orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/memberships/${encodeURIComponent(username)}`,
@@ -238,6 +288,9 @@ export class GitHubIssueClient {
       }),
     });
   }
+  async revokeOrgInvitation(org: string, invitationId: number): Promise<void> {
+    await this.req(`orgs/${encodeURIComponent(org)}/invitations/${invitationId}`, { method: "DELETE" });
+  }
   async listOrgOutsideCollaborators(org: string): Promise<CollaboratorResponse[]> {
     return this.req<CollaboratorResponse[]>(`orgs/${encodeURIComponent(org)}/outside_collaborators`, { method: "GET" });
   }
@@ -250,6 +303,12 @@ export class GitHubIssueClient {
   async declineUserOrgInvitation(invitationId: number): Promise<void> {
     await this.req(`user/organization_invitations/${invitationId}`, { method: "DELETE" });
   }
+  async transferRepo(owner: string, repo: string, newOwner: string): Promise<RepoResponse> {
+    return this.req<RepoResponse>(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/transfer`, {
+      method: "POST",
+      body: JSON.stringify({ new_owner: newOwner }),
+    });
+  }
   async ensureLabels(labels: string[]): Promise<void> {
     for (const label of labels) {
       if (!label.trim()) continue;

package/src/memory.test.ts

@@ -1,5 +1,6 @@
-import { MemoryStore, mergeMemoryCandidates, scoreMemoryMatch } from "./memory.js";
+import { MemoryStore, mergeMemoryCandidates } from "./memory.js";
 import type { ParsedMemoryIssue } from "./types.js";
+import { sha256 } from "./utils.js";
 import { stringifyFlatYaml } from "./yaml.js";
 
 function memory(overrides: Partial<ParsedMemoryIssue> = {}): ParsedMemoryIssue {
@@ -41,18 +42,6 @@ function assert(condition: unknown, message: string): void {
   if (!condition) throw new Error(message);
 }
 
-function testConfig(): never {
-  return {
-    memoryRecallLimit: 5,
-    memoryAutoRecallLimit: 3,
-    turnCommentDelayMs: 1000,
-    digestWaitTimeoutMs: 30000,
-    summaryWaitTimeoutMs: 120000,
-    memoryExtractWaitTimeoutMs: 45000,
-    memoryReconcileWaitTimeoutMs: 45000,
-  } as never;
-}
-
 async function testBackendSearchBuildsSingleCleanedQuery(): Promise<void> {
   const queries: string[] = [];
   const client = {
@@ -62,7 +51,7 @@ async function testBackendSearchBuildsSingleCleanedQuery(): Promise<void> {
       return [] as IssueRecord[];
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   await store.search([
     "<clawmem-context>",
     "- [11] Previous memory that should be stripped",
@@ -111,7 +100,7 @@ async function testBackendSearchPreferredForRecall(): Promise<void> {
       return searched;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const found = await store.search("redis rate limiting", 1);
 
   assert(queries.length === 1, "expected backend search to be called once");
@@ -135,7 +124,7 @@ async function testBackendSearchReturnsEmptyWithoutLexicalFallback(): Promise<vo
     listIssues: async () => issues,
     searchIssues: async () => [] as IssueRecord[],
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const found = await store.search("redis rate limiting", 5);
 
   assert(found.length === 0, "expected backend-only recall to return no results when the backend finds nothing");
@@ -146,7 +135,7 @@ async function testBackendSearchPropagatesErrors(): Promise<void> {
     repo: () => "owner/main-memory",
     searchIssues: async () => { throw new Error("search unavailable"); },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   let message = "";
   try {
     await store.search("redis rate limiting", 5);
@@ -157,25 +146,6 @@ async function testBackendSearchPropagatesErrors(): Promise<void> {
   assert(message.includes("search unavailable"), "expected backend failures to propagate instead of falling back locally");
 }
 
-function testCjkScoring(): void {
-  const billing = memory({
-    issueNumber: 3,
-    title: "Memory: 账单修复流程",
-    detail: "遇到账单不一致时，先核对 invoice_id，再补发 webhook。",
-    topics: ["账单", "支付"],
-  });
-  const unrelated = memory({
-    issueNumber: 4,
-    title: "Memory: 部署备注",
-    detail: "发布前需要确认灰度流量比例。",
-    topics: ["部署"],
-  });
-  const billingScore = scoreMemoryMatch(billing, "账单 webhook");
-  const unrelatedScore = scoreMemoryMatch(unrelated, "账单 webhook");
-  assert(billingScore > unrelatedScore, "expected Chinese query scoring to prefer the billing memory");
-  assert(billingScore > 0, "expected Chinese query to produce a positive match score");
-}
-
 function testMergeMemoryCandidates(): void {
   const merged = mergeMemoryCandidates(
     [
@@ -207,6 +177,8 @@ async function testStructuredStoreAndSchema(): Promise<void> {
   const ensured: string[][] = [];
   const labels: LabelRecord[] = [{ name: "kind:lesson" }, { name: "topic:redis" }];
   const client = {
+    repo: () => "owner/main-memory",
+    searchIssues: async () => [] as IssueRecord[],
     listIssues: async () => [] as IssueRecord[],
     listLabels: async () => labels,
     ensureLabels: async (next: string[]) => { ensured.push(next); },
@@ -215,7 +187,7 @@ async function testStructuredStoreAndSchema(): Promise<void> {
       return { number: 99, title: payload.title };
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const result = await store.store({ detail: "Redis Lua scripts are required for atomic rate limiting.", kind: "Lesson", topics: ["Redis Ops", "rate_limit"] });
   const schema = await store.listSchema();
 
@@ -236,6 +208,47 @@ async function testStructuredStoreAndSchema(): Promise<void> {
   assert(schema.topics.includes("redis"), "expected schema to expose existing topic labels");
 }
 
+async function testListSchemaPrefersLabelsWithoutIssueScan(): Promise<void> {
+  const client = {
+    listLabels: async () => [{ name: "kind:lesson" }, { name: "topic:redis" }, { name: "topic:rate-limit" }],
+    listIssues: async () => { throw new Error("listSchema should not scan issues when label schema is available"); },
+  };
+  const store = new MemoryStore(client as never);
+  const schema = await store.listSchema();
+
+  assert(JSON.stringify(schema.kinds) === JSON.stringify(["lesson"]), "expected schema kinds to come from labels");
+  assert(JSON.stringify(schema.topics) === JSON.stringify(["rate-limit", "redis"]), "expected schema topics to come from labels");
+}
+
+async function testStoreDeduplicatesViaHashSearch(): Promise<void> {
+  const detail = "Redis Lua scripts are required for atomic rate limiting.";
+  const hash = sha256(detail);
+  const existing = memory({
+    issueNumber: 77,
+    detail,
+    memoryHash: hash,
+    kind: "lesson",
+    topics: ["redis-ops"],
+  });
+  const queries: string[] = [];
+  const client = {
+    repo: () => "owner/main-memory",
+    searchIssues: async (query: string) => {
+      queries.push(query);
+      return [issueFromMemory(existing)];
+    },
+    listIssues: async () => { throw new Error("store should not scan all active memories"); },
+    ensureLabels: async () => {},
+    createIssue: async () => { throw new Error("store should not create a duplicate issue"); },
+  };
+  const store = new MemoryStore(client as never);
+  const result = await store.store({ detail, kind: "lesson", topics: ["redis_ops"] });
+
+  assert(result.created === false, "expected hash search to reuse an existing exact duplicate");
+  assert(result.memory.issueNumber === 77, "expected hash search to return the existing memory");
+  assert(queries.length === 1 && queries[0]?.includes(hash), "expected store to query by memory hash");
+}
+
 async function testStoreKeepsFullAutoTitleAndSupportsExplicitTitle(): Promise<void> {
   const created: Array<{ title: string; body: string; labels: string[] }> = [];
   const client = {
@@ -247,7 +260,7 @@ async function testStoreKeepsFullAutoTitleAndSupportsExplicitTitle(): Promise<vo
       return { number: created.length + 100, title: payload.title };
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const longDetail = "Tech Decision #001: Frontend = React Native, Backend = FastAPI, Database = PostgreSQL, and analytics events must stay append-only for auditability.";
   const auto = await store.store({ detail: longDetail });
   const explicit = await store.store({ title: "Architecture Decision #001", detail: "Use React Native + FastAPI for the first mobile stack." });
@@ -284,6 +297,11 @@ async function testGetAndListMemories(): Promise<void> {
     })),
   ];
   const client = {
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -295,7 +313,7 @@ async function testGetAndListMemories(): Promise<void> {
       });
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const exact = await store.get("4");
   const activeFacts = await store.listMemories({ status: "active", kind: "core-fact", limit: 10 });
   const sports = await store.listMemories({ status: "all", topic: "sports", limit: 10 });
@@ -317,6 +335,11 @@ async function testLegacyMemoriesWithoutSessionOrDate(): Promise<void> {
   ];
   const client = {
     repo: () => "owner/main-memory",
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -329,7 +352,7 @@ async function testLegacyMemoriesWithoutSessionOrDate(): Promise<void> {
     },
     searchIssues: async () => issues,
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const exact = await store.get("4");
   const recalled = await store.search("F1 Dota 2", 5);
 
@@ -352,6 +375,11 @@ async function testUpdateMemoryInPlace(): Promise<void> {
   const updatedIssues: Array<{ number: number; title?: string; body?: string }> = [];
   const syncedLabels: Array<{ number: number; labels: string[] }> = [];
   const client = {
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -378,7 +406,7 @@ async function testUpdateMemoryInPlace(): Promise<void> {
       issue.labels = labels;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const updated = await store.update("4", {
     detail: "xiangz likes F1, watches Dota 2 as a viewer, and recently follows tennis.",
     topics: ["preferences", "sports"],
@@ -407,6 +435,11 @@ async function testUpdateSupportsExplicitRetitle(): Promise<void> {
   ];
   const updatedIssues: Array<{ number: number; title?: string; body?: string }> = [];
   const client = {
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -428,13 +461,58 @@ async function testUpdateSupportsExplicitRetitle(): Promise<void> {
     },
     syncManagedLabels: async () => {},
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const updated = await store.update("20", { title: "Billing Audit Convention" });
 
   assert(updated?.title === "Memory: Billing Audit Convention", "expected memory_update to support explicit retitle");
   assert(updatedIssues[0]?.title === "Memory: Billing Audit Convention", "expected issue title patch to use the explicit retitle");
 }
 
+async function testUpdateUsesHashSearchForDuplicateCheck(): Promise<void> {
+  const currentDetail = "We use append-only audit events for billing changes.";
+  const conflictingDetail = "Billing events must stay append-only for auditability.";
+  const current = issueFromMemory(memory({
+    issueNumber: 20,
+    title: "Memory: billing convention",
+    detail: currentDetail,
+    memoryHash: sha256(currentDetail),
+    kind: "convention",
+  }));
+  const conflicting = issueFromMemory(memory({
+    issueNumber: 21,
+    title: "Memory: audit rule",
+    detail: conflictingDetail,
+    memoryHash: sha256(conflictingDetail),
+    kind: "convention",
+  }));
+  const queries: string[] = [];
+  const client = {
+    repo: () => "owner/main-memory",
+    getIssue: async (number: number) => {
+      if (number === 20) return current;
+      throw new Error("issue missing");
+    },
+    searchIssues: async (query: string) => {
+      queries.push(query);
+      return [conflicting];
+    },
+    listIssues: async () => { throw new Error("update should not scan all active memories when direct lookup/search are available"); },
+    ensureLabels: async () => {},
+    updateIssue: async () => { throw new Error("duplicate update should fail before mutating"); },
+    syncManagedLabels: async () => {},
+  };
+  const store = new MemoryStore(client as never);
+  let message = "";
+  try {
+    await store.update("20", { detail: conflictingDetail });
+  } catch (error) {
+    message = String(error);
+  }
+
+  assert(message.includes("[21]"), "expected duplicate detection to reference the conflicting memory");
+  assert(queries.length === 1 && queries[0]?.includes(sha256(conflictingDetail)), "expected update duplicate checks to search by memory hash");
+}
+
 async function testForgetClosesMemoryIssue(): Promise<void> {
   const issues: IssueRecord[] = [
     issueFromMemory(memory({
@@ -448,6 +526,11 @@ async function testForgetClosesMemoryIssue(): Promise<void> {
   const syncedLabels: Array<{ number: number; labels: string[] }> = [];
   const updatedIssues: Array<{ number: number; state?: "open" | "closed" }> = [];
   const client = {
+    getIssue: async (number: number) => {
+      const issue = issues.find((entry) => entry.number === number);
+      if (!issue) throw new Error("issue missing");
+      return issue;
+    },
     listIssues: async (params?: { labels?: string[]; state?: "open" | "closed" | "all" }) => {
       const labels = params?.labels ?? [];
       const state = params?.state ?? "open";
@@ -472,7 +555,7 @@ async function testForgetClosesMemoryIssue(): Promise<void> {
       return issue;
     },
   };
-  const store = new MemoryStore(client as never, {} as never, testConfig());
+  const store = new MemoryStore(client as never);
   const forgotten = await store.forget("12");
 
   assert(forgotten?.status === "stale", "expected forgotten memory to be returned as stale");
@@ -485,15 +568,17 @@ async function main(): Promise<void> {
   await testBackendSearchPreferredForRecall();
   await testBackendSearchReturnsEmptyWithoutLexicalFallback();
   await testBackendSearchPropagatesErrors();
-testCjkScoring();
-testMergeMemoryCandidates();
-await testStructuredStoreAndSchema();
+  testMergeMemoryCandidates();
+  await testStructuredStoreAndSchema();
+  await testListSchemaPrefersLabelsWithoutIssueScan();
+  await testStoreDeduplicatesViaHashSearch();
   await testStoreKeepsFullAutoTitleAndSupportsExplicitTitle();
   await testGetAndListMemories();
   await testLegacyMemoriesWithoutSessionOrDate();
   await testUpdateMemoryInPlace();
   await testUpdateSupportsExplicitRetitle();
   await testForgetClosesMemoryIssue();
+  await testUpdateUsesHashSearchForDuplicateCheck();
   console.log("memory tests passed");
 }