@clawmem-ai/clawmem 0.1.18 → 0.1.19

package/dist/src/github-client.js

@@ -0,0 +1,350 @@
+// GitHub Issues API client for clawmem. No label caching — idempotent create-if-absent.
+import { resolveLabelColor, labelDescription, extractLabelNames, isManagedLabel } from "./config.js";
+export class GitHubIssueClient {
+    config;
+    log;
+    constructor(config, log) {
+        this.config = config;
+        this.log = log;
+    }
+    repo() {
+        return this.config.repo?.trim() || undefined;
+    }
+    defaultRepo() {
+        return this.config.defaultRepo?.trim() || undefined;
+    }
+    async createIssue(params) {
+        return this.req(this.repoPath("issues"), {
+            method: "POST",
+            body: JSON.stringify({
+                title: params.title,
+                ...(params.body !== undefined ? { body: params.body } : {}),
+                ...(params.labels && params.labels.length > 0 ? { labels: params.labels } : {}),
+                ...(params.assignees && params.assignees.length > 0 ? { assignees: params.assignees } : {}),
+                ...(params.assignee ? { assignee: params.assignee } : {}),
+                ...(params.state ? { state: params.state } : {}),
+                ...(params.stateReason ? { state_reason: params.stateReason } : {}),
+            }),
+        });
+    }
+    async updateIssue(n, params) {
+        return this.req(this.repoPath(`issues/${n}`), {
+            method: "PATCH",
+            body: JSON.stringify({
+                ...(params.title !== undefined ? { title: params.title } : {}),
+                ...(params.body !== undefined ? { body: params.body } : {}),
+                ...(params.state !== undefined ? { state: params.state } : {}),
+                ...(params.stateReason !== undefined ? { state_reason: params.stateReason } : {}),
+                ...(params.labels !== undefined ? { labels: params.labels } : {}),
+                ...(params.assignees !== undefined ? { assignees: params.assignees } : {}),
+                ...(params.locked !== undefined ? { locked: params.locked } : {}),
+            }),
+        });
+    }
+    async getIssue(n) {
+        return this.req(this.repoPath(`issues/${n}`), { method: "GET" });
+    }
+    async createComment(issueNumber, body, params) {
+        return this.req(this.repoPath(`issues/${issueNumber}/comments`), {
+            method: "POST",
+            body: JSON.stringify({
+                body,
+                ...(typeof params?.inReplyTo === "number" ? { in_reply_to: params.inReplyTo } : {}),
+            }),
+        });
+    }
+    async listComments(issueNumber, params) {
+        const q = new URLSearchParams();
+        q.set("page", String(params?.page ?? 1));
+        q.set("per_page", String(params?.perPage ?? 100));
+        if (params?.sort)
+            q.set("sort", params.sort);
+        if (params?.direction)
+            q.set("direction", params.direction);
+        if (params?.since)
+            q.set("since", params.since);
+        if (params?.threaded)
+            q.set("threaded", "true");
+        return this.req(`${this.repoPath(`issues/${issueNumber}/comments`)}?${q}`, { method: "GET" });
+    }
+    async listIssues(params) {
+        const q = new URLSearchParams();
+        q.set("state", params.state ?? "open");
+        q.set("page", String(params.page ?? 1));
+        q.set("per_page", String(params.perPage ?? 100));
+        if (params.labels?.length)
+            q.set("labels", params.labels.join(","));
+        if (params.assignee)
+            q.set("assignee", params.assignee);
+        if (params.creator)
+            q.set("creator", params.creator);
+        if (params.mentioned)
+            q.set("mentioned", params.mentioned);
+        if (params.sort)
+            q.set("sort", params.sort);
+        if (params.direction)
+            q.set("direction", params.direction);
+        if (params.since)
+            q.set("since", params.since);
+        return this.req(`${this.repoPath("issues")}?${q}`, { method: "GET" });
+    }
+    async searchIssues(query, params) {
+        const q = new URLSearchParams();
+        q.set("q", query);
+        q.set("page", String(params?.page ?? 1));
+        q.set("per_page", String(params?.perPage ?? 100));
+        const res = await this.req(`search/issues?${q}`, { method: "GET" });
+        return Array.isArray(res?.items) ? res.items : [];
+    }
+    async listLabels(params) {
+        const q = new URLSearchParams();
+        q.set("page", String(params?.page ?? 1));
+        q.set("per_page", String(params?.perPage ?? 100));
+        return this.req(`${this.repoPath("labels")}?${q}`, { method: "GET" });
+    }
+    async listUserRepos() {
+        return this.req("user/repos", { method: "GET" });
+    }
+    async createUserRepo(params) {
+        return this.req("user/repos", {
+            method: "POST",
+            body: JSON.stringify({
+                name: params.name,
+                ...(params.description ? { description: params.description } : {}),
+                private: params.private ?? true,
+                auto_init: params.autoInit ?? false,
+            }),
+        });
+    }
+    async createOrgRepo(org, params) {
+        return this.req(`orgs/${encodeURIComponent(org)}/repos`, {
+            method: "POST",
+            body: JSON.stringify({
+                name: params.name,
+                ...(params.description ? { description: params.description } : {}),
+                private: params.private ?? true,
+                auto_init: params.autoInit ?? false,
+                ...(params.hasIssues !== undefined ? { has_issues: params.hasIssues } : {}),
+                ...(params.hasWiki !== undefined ? { has_wiki: params.hasWiki } : {}),
+            }),
+        });
+    }
+    async listUserOrgs() {
+        return this.req("user/orgs", { method: "GET" });
+    }
+    async getCurrentUser() {
+        return this.req("user", { method: "GET" });
+    }
+    async createUserOrg(params) {
+        return this.req("user/orgs", {
+            method: "POST",
+            body: JSON.stringify({
+                login: params.login,
+                ...(params.name ? { name: params.name } : {}),
+                ...(params.defaultRepositoryPermission ? { default_repository_permission: params.defaultRepositoryPermission } : {}),
+            }),
+        });
+    }
+    async getOrg(org) {
+        return this.req(`orgs/${encodeURIComponent(org)}`, { method: "GET" });
+    }
+    async listOrgMembers(org, role) {
+        const q = new URLSearchParams();
+        if (role)
+            q.set("role", role);
+        const suffix = q.toString();
+        return this.req(`orgs/${encodeURIComponent(org)}/members${suffix ? `?${suffix}` : ""}`, { method: "GET" });
+    }
+    async getOrgMembership(org, username) {
+        return this.req(`orgs/${encodeURIComponent(org)}/memberships/${encodeURIComponent(username)}`, { method: "GET" });
+    }
+    async removeOrgMember(org, username) {
+        await this.req(`orgs/${encodeURIComponent(org)}/members/${encodeURIComponent(username)}`, { method: "DELETE" });
+    }
+    async removeOrgMembership(org, username) {
+        await this.req(`orgs/${encodeURIComponent(org)}/memberships/${encodeURIComponent(username)}`, { method: "DELETE" });
+    }
+    async listOrgTeams(org) {
+        return this.req(`orgs/${encodeURIComponent(org)}/teams`, { method: "GET" });
+    }
+    async getTeam(org, teamSlug) {
+        return this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}`, { method: "GET" });
+    }
+    async createOrgTeam(org, params) {
+        return this.req(`orgs/${encodeURIComponent(org)}/teams`, {
+            method: "POST",
+            body: JSON.stringify({
+                name: params.name,
+                ...(params.description ? { description: params.description } : {}),
+                privacy: params.privacy ?? "closed",
+            }),
+        });
+    }
+    async updateTeam(org, teamSlug, params) {
+        return this.req(`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, teamSlug) {
+        await this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}`, { method: "DELETE" });
+    }
+    async listTeamMembers(org, teamSlug) {
+        return this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/members`, { method: "GET" });
+    }
+    async setTeamMembership(org, teamSlug, username, role) {
+        return this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/memberships/${encodeURIComponent(username)}`, { method: "PUT", body: JSON.stringify({ role }) });
+    }
+    async removeTeamMembership(org, teamSlug, username) {
+        await this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/memberships/${encodeURIComponent(username)}`, { method: "DELETE" });
+    }
+    async listTeamRepos(org, teamSlug) {
+        return this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/repos`, { method: "GET" });
+    }
+    async setTeamRepoAccess(org, teamSlug, owner, repo, permission) {
+        await this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`, { method: "PUT", body: JSON.stringify({ permission }) });
+    }
+    async removeTeamRepoAccess(org, teamSlug, owner, repo) {
+        await this.req(`orgs/${encodeURIComponent(org)}/teams/${encodeURIComponent(teamSlug)}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`, { method: "DELETE" });
+    }
+    async listRepoCollaborators(owner, repo) {
+        return this.req(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/collaborators`, { method: "GET" });
+    }
+    async listRepoInvitations(owner, repo) {
+        return this.req(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/invitations`, { method: "GET" });
+    }
+    async setRepoCollaborator(owner, repo, username, permission) {
+        return this.req(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/collaborators/${encodeURIComponent(username)}`, { method: "PUT", body: JSON.stringify({ permission }) });
+    }
+    async removeRepoCollaborator(owner, repo, username) {
+        await this.req(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/collaborators/${encodeURIComponent(username)}`, { method: "DELETE" });
+    }
+    async getRepo(owner, repo) {
+        return this.req(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`, { method: "GET" });
+    }
+    async listUserRepoInvitations() {
+        return this.req("user/repository_invitations", { method: "GET" });
+    }
+    async acceptUserRepoInvitation(invitationId) {
+        await this.req(`user/repository_invitations/${invitationId}`, { method: "PATCH" });
+    }
+    async declineUserRepoInvitation(invitationId) {
+        await this.req(`user/repository_invitations/${invitationId}`, { method: "DELETE" });
+    }
+    async listOrgInvitations(org) {
+        return this.req(`orgs/${encodeURIComponent(org)}/invitations`, { method: "GET" });
+    }
+    async createOrgInvitation(org, params) {
+        return this.req(`orgs/${encodeURIComponent(org)}/invitations`, {
+            method: "POST",
+            body: JSON.stringify({
+                invitee_login: params.inviteeLogin,
+                role: params.role ?? "member",
+                ...(params.teamIds && params.teamIds.length > 0 ? { team_ids: params.teamIds } : {}),
+                ...(typeof params.expiresInDays === "number" ? { expires_in_days: params.expiresInDays } : {}),
+            }),
+        });
+    }
+    async revokeOrgInvitation(org, invitationId) {
+        await this.req(`orgs/${encodeURIComponent(org)}/invitations/${invitationId}`, { method: "DELETE" });
+    }
+    async listOrgOutsideCollaborators(org) {
+        return this.req(`orgs/${encodeURIComponent(org)}/outside_collaborators`, { method: "GET" });
+    }
+    async listUserOrgInvitations() {
+        return this.req("user/organization_invitations", { method: "GET" });
+    }
+    async acceptUserOrgInvitation(invitationId) {
+        await this.req(`user/organization_invitations/${invitationId}`, { method: "PATCH" });
+    }
+    async declineUserOrgInvitation(invitationId) {
+        await this.req(`user/organization_invitations/${invitationId}`, { method: "DELETE" });
+    }
+    async transferRepo(owner, repo, newOwner, newRepoName) {
+        return this.req(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/transfer`, {
+            method: "POST",
+            body: JSON.stringify({
+                new_owner: newOwner,
+                ...(newRepoName ? { new_repo_name: newRepoName } : {}),
+            }),
+        });
+    }
+    async renameRepo(owner, repo, newName) {
+        return this.req(`repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`, {
+            method: "PATCH",
+            body: JSON.stringify({ name: newName }),
+        });
+    }
+    async ensureLabels(labels) {
+        for (const label of labels) {
+            if (!label.trim())
+                continue;
+            await this.req(this.repoPath("labels"), { method: "POST",
+                body: JSON.stringify({ name: label, color: resolveLabelColor(label), description: labelDescription(label) }) }, { allowValidationError: true });
+        }
+    }
+    async syncManagedLabels(issueNumber, desired) {
+        const issue = await this.getIssue(issueNumber);
+        const unmanaged = extractLabelNames(issue.labels).filter((l) => !isManagedLabel(l));
+        await this.updateIssue(issueNumber, { labels: [...new Set([...unmanaged, ...desired])] });
+    }
+    async getRepoInfo() {
+        return this.req(this.repoPath("").replace(/\/$/, ""), { method: "GET" });
+    }
+    async updateRepoDescription(description) {
+        await this.req(this.repoPath("").replace(/\/$/, ""), { method: "PATCH", body: JSON.stringify({ description }) });
+    }
+    async registerAgent(prefixLogin, defaultRepoName) {
+        return this.req("agents", {
+            method: "POST",
+            body: JSON.stringify({
+                prefix_login: prefixLogin,
+                default_repo_name: defaultRepoName,
+            }),
+        }, { omitAuth: true });
+    }
+    async createAnonymousSession(locale) {
+        const body = locale ? JSON.stringify({ locale }) : undefined;
+        return this.req("anonymous/session", { method: "POST", ...(body ? { body } : {}) }, { omitAuth: true });
+    }
+    repoPath(suffix) {
+        if (!this.config.repo)
+            throw new Error("clawmem repository is not configured");
+        return `repos/${this.config.repo}/${suffix}`;
+    }
+    async req(pathname, init, opts = {}) {
+        if (!this.config.baseUrl)
+            throw new Error("clawmem baseUrl is not configured");
+        if (!opts.omitAuth && !this.config.token)
+            throw new Error("clawmem token is not configured");
+        const base = this.config.baseUrl.replace(/\/+$/, "");
+        const headers = { Accept: "application/vnd.github+json", "Content-Type": "application/json" };
+        if (!opts.omitAuth)
+            headers.Authorization = this.config.authScheme === "bearer" ? `Bearer ${this.config.token}` : `token ${this.config.token}`;
+        const res = await fetch(new URL(pathname, `${base}/`), { ...init, headers: { ...headers, ...(init.headers ?? {}) } });
+        if (res.status === 404 && opts.allowNotFound)
+            return undefined;
+        if (res.status === 422 && opts.allowValidationError)
+            return undefined;
+        if (!res.ok) {
+            const d = await res.text();
+            throw new Error(`HTTP ${res.status}: ${d || res.statusText}`);
+        }
+        if (res.status === 204)
+            return undefined;
+        const text = await res.text();
+        if (!text.trim())
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch (e) {
+            this.log.warn?.(`clawmem: failed to parse API response: ${String(e)}`);
+            return undefined;
+        }
+    }
+}

package/dist/src/keyed-async-queue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A keyed async queue that serializes async tasks per key.
+ * Inlined from openclaw/plugin-sdk/keyed-async-queue to avoid
+ * dependency on platform internals that may not exist in older versions.
+ *
+ * Matches the behaviour of the upstream implementation: a failed task
+ * does not block subsequent tasks on the same key.
+ */
+export declare class KeyedAsyncQueue {
+    private readonly tails;
+    enqueue<T>(key: string, task: () => Promise<T>): Promise<T>;
+}

package/dist/src/keyed-async-queue.js

@@ -0,0 +1,23 @@
+/**
+ * A keyed async queue that serializes async tasks per key.
+ * Inlined from openclaw/plugin-sdk/keyed-async-queue to avoid
+ * dependency on platform internals that may not exist in older versions.
+ *
+ * Matches the behaviour of the upstream implementation: a failed task
+ * does not block subsequent tasks on the same key.
+ */
+export class KeyedAsyncQueue {
+    tails = new Map();
+    enqueue(key, task) {
+        const current = (this.tails.get(key) ?? Promise.resolve())
+            .catch(() => void 0)
+            .then(task);
+        const tail = current.then(() => void 0, () => void 0);
+        this.tails.set(key, tail);
+        tail.finally(() => {
+            if (this.tails.get(key) === tail)
+                this.tails.delete(key);
+        });
+        return current;
+    }
+}

package/dist/src/memory.d.ts

@@ -0,0 +1,29 @@
+import type { GitHubIssueClient } from "./github-client.js";
+import type { MemoryCandidate, MemoryDraft, MemoryListOptions, MemorySchema, ParsedMemoryIssue } from "./types.js";
+export declare class MemoryStore {
+    private readonly client;
+    constructor(client: GitHubIssueClient);
+    search(query: string, limit: number): Promise<ParsedMemoryIssue[]>;
+    listSchema(): Promise<MemorySchema>;
+    get(memoryId: string, status?: "active" | "stale" | "all"): Promise<ParsedMemoryIssue | null>;
+    listMemories(options?: MemoryListOptions): Promise<ParsedMemoryIssue[]>;
+    store(draft: MemoryDraft): Promise<{
+        created: boolean;
+        memory: ParsedMemoryIssue;
+    }>;
+    update(memoryId: string, patch: {
+        title?: string;
+        detail?: string;
+        kind?: string;
+        topics?: string[];
+    }): Promise<ParsedMemoryIssue | null>;
+    forget(memoryId: string): Promise<ParsedMemoryIssue | null>;
+    private searchViaBackend;
+    private findActiveByHash;
+    private findByRef;
+    private findActiveByRef;
+    private parseIssue;
+    private mergeSchema;
+}
+export declare function parseCandidates(raw: string): MemoryCandidate[];
+export declare function mergeMemoryCandidates(base: MemoryCandidate[], next: MemoryCandidate[]): MemoryCandidate[];