@mingxy/cerebro 1.6.8 → 1.7.0

package/dist/logger.js

@@ -0,0 +1,42 @@
+import { appendFileSync, mkdirSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const LOG_DIR = join(homedir(), ".config", "ourmem");
+const LOG_FILE = join(LOG_DIR, "plugin.log");
+function ensureLogDir() {
+    if (!existsSync(LOG_DIR)) {
+        try {
+            mkdirSync(LOG_DIR, { recursive: true });
+        }
+        catch {
+            // silently fail if we can't create log directory
+        }
+    }
+}
+function writeLog(level, ...args) {
+    ensureLogDir();
+    const timestamp = new Date().toISOString();
+    const message = args
+        .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
+        .join(" ");
+    const line = `[${timestamp}] [${level}] ${message}\n`;
+    try {
+        appendFileSync(LOG_FILE, line);
+    }
+    catch {
+        // silently fail if we can't write to log file
+    }
+}
+export function logInfo(...args) {
+    writeLog("INFO", ...args);
+}
+export function logWarn(...args) {
+    writeLog("WARN", ...args);
+}
+export function logError(...args) {
+    writeLog("ERROR", ...args);
+}
+export function logDebug(...args) {
+    writeLog("DEBUG", ...args);
+}
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;AACrD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;AAE7C,SAAS,YAAY;IACnB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QACzB,IAAI,CAAC;YACH,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1C,CAAC;QAAC,MAAM,CAAC;YACP,iDAAiD;QACnD,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,KAAa,EAAE,GAAG,IAAe;IACjD,YAAY,EAAE,CAAC;IACf,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC3C,MAAM,OAAO,GAAG,IAAI;SACjB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;SAC3D,IAAI,CAAC,GAAG,CAAC,CAAC;IACb,MAAM,IAAI,GAAG,IAAI,SAAS,MAAM,KAAK,KAAK,OAAO,IAAI,CAAC;IACtD,IAAI,CAAC;QACH,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,8CAA8C;IAChD,CAAC;AACH,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,GAAG,IAAe;IACxC,QAAQ,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,GAAG,IAAe;IACxC,QAAQ,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,GAAG,IAAe;IACzC,QAAQ,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,GAAG,IAAe;IACzC,QAAQ,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;AAC7B,CAAC"}

package/dist/privacy.d.ts

@@ -0,0 +1,3 @@
+export declare function stripPrivateContent(text: string): string;
+export declare function isFullyPrivate(text: string): boolean;
+//# sourceMappingURL=privacy.d.ts.map

package/dist/privacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacy.d.ts","sourceRoot":"","sources":["../src/privacy.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKpD"}

package/dist/privacy.js

@@ -0,0 +1,10 @@
+export function stripPrivateContent(text) {
+    return text.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]");
+}
+export function isFullyPrivate(text) {
+    const stripped = stripPrivateContent(text)
+        .replace(/\[REDACTED\]/g, "")
+        .trim();
+    return stripped.length === 0;
+}
+//# sourceMappingURL=privacy.js.map

package/dist/privacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacy.js","sourceRoot":"","sources":["../src/privacy.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,OAAO,IAAI,CAAC,OAAO,CAAC,gCAAgC,EAAE,YAAY,CAAC,CAAC;AACtE,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,QAAQ,GAAG,mBAAmB,CAAC,IAAI,CAAC;SACvC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC;SAC5B,IAAI,EAAE,CAAC;IACV,OAAO,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC;AAC/B,CAAC"}

package/dist/tags.d.ts

@@ -0,0 +1,3 @@
+export declare function getUserTag(email: string): string;
+export declare function getProjectTag(directory: string): string;
+//# sourceMappingURL=tags.d.ts.map

package/dist/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../src/tags.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAMvD"}

package/dist/tags.js

@@ -0,0 +1,13 @@
+import { createHash } from "crypto";
+export function getUserTag(email) {
+    const hash = createHash("sha256").update(email).digest("hex").slice(0, 16);
+    return `omem_user_${hash}`;
+}
+export function getProjectTag(directory) {
+    const hash = createHash("sha256")
+        .update(directory)
+        .digest("hex")
+        .slice(0, 16);
+    return `omem_project_${hash}`;
+}
+//# sourceMappingURL=tags.js.map

package/dist/tags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.js","sourceRoot":"","sources":["../src/tags.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC3E,OAAO,aAAa,IAAI,EAAE,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,SAAiB;IAC7C,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC;SAC9B,MAAM,CAAC,SAAS,CAAC;SACjB,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAChB,OAAO,gBAAgB,IAAI,EAAE,CAAC;AAChC,CAAC"}

package/dist/tools.d.ts

@@ -0,0 +1,202 @@
+import type { OmemClient } from "./client.js";
+export interface ToolContext {
+    agentId?: string;
+    getSessionId: () => string | undefined;
+}
+export declare function buildTools(client: OmemClient, containerTags: string[], context: ToolContext): {
+    memory_store: {
+        description: string;
+        args: {
+            content: import("zod").ZodString;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            source: import("zod").ZodString;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+            visibility: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            content: string;
+            source: string;
+            tags?: string[] | undefined;
+            scope?: string | undefined;
+            visibility?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_search: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_get: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_update: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            content: import("zod").ZodString;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        };
+        execute(args: {
+            id: string;
+            content: string;
+            tags?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_profile: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_list: {
+        description: string;
+        args: {
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    session_recalls: {
+        description: string;
+        args: {
+            session_id: import("zod").ZodString;
+        };
+        execute(args: {
+            session_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_ingest: {
+        description: string;
+        args: {
+            messages: import("zod").ZodArray<import("zod").ZodObject<{
+                role: import("zod").ZodString;
+                content: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                smart: "smart";
+                raw: "raw";
+            }>>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            session_id: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            messages: {
+                role: string;
+                content: string;
+            }[];
+            mode?: "smart" | "raw" | undefined;
+            tags?: string[] | undefined;
+            session_id?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_stats: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_delete: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    space_create: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            space_type: import("zod").ZodString;
+            members: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                user_id: import("zod").ZodString;
+                role: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>>;
+        };
+        execute(args: {
+            name: string;
+            space_type: string;
+            members?: {
+                user_id: string;
+                role: string;
+            }[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    space_list: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    space_add_member: {
+        description: string;
+        args: {
+            space_id: import("zod").ZodString;
+            user_id: import("zod").ZodString;
+            role: import("zod").ZodString;
+        };
+        execute(args: {
+            space_id: string;
+            user_id: string;
+            role: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_share: {
+        description: string;
+        args: {
+            memory_id: import("zod").ZodString;
+            target_space: import("zod").ZodString;
+        };
+        execute(args: {
+            memory_id: string;
+            target_space: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_pull: {
+        description: string;
+        args: {
+            memory_id: import("zod").ZodString;
+            source_space: import("zod").ZodString;
+            visibility: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            memory_id: string;
+            source_space: string;
+            visibility?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_reshare: {
+        description: string;
+        args: {
+            memory_id: import("zod").ZodString;
+            target_space: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            memory_id: string;
+            target_space?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+    memory_toggle: {
+        description: string;
+        args: {
+            state: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            state?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    };
+};
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAsB9C,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CACxC;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuX3F"}

package/dist/tools.js

@@ -0,0 +1,337 @@
+import { tool } from "@opencode-ai/plugin";
+import { isAutoStoreEnabled, setAutoStoreEnabled } from "./index.js";
+function extractMemoryIds(result) {
+    if (!result)
+        return [];
+    if (Array.isArray(result)) {
+        return result.map((m) => m.id).filter(Boolean);
+    }
+    if (typeof result === "object" && result !== null) {
+        const r = result;
+        if (Array.isArray(r.memories)) {
+            return r.memories.map((m) => m.id).filter(Boolean);
+        }
+        if (Array.isArray(r.results)) {
+            return r.results
+                .map((m) => m.id ?? m.memory?.id)
+                .filter(Boolean);
+        }
+    }
+    return [];
+}
+export function buildTools(client, containerTags, context) {
+    return {
+        memory_store: tool({
+            description: "Store a new memory in the user's long-term memory. " +
+                "Use when the user explicitly asks to remember something, " +
+                "or when you identify important preferences, facts, or decisions worth preserving.",
+            args: {
+                content: tool.schema.string().describe("The information to remember"),
+                tags: tool.schema
+                    .array(tool.schema.string())
+                    .optional()
+                    .describe("Optional categorization tags"),
+                source: tool.schema
+                    .string()
+                    .describe("Origin context, e.g. 'conversation', 'code-review', 'user-input'"),
+                scope: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Memory scope: 'project' (default, only visible in this project) or 'global' (visible across all projects)"),
+                visibility: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Memory visibility: 'global' (default, visible to all agents) or 'private' (only visible to the storing agent). Use 'private' for sensitive data like credentials, personal info, or anything the user wouldn't want shared."),
+            },
+            async execute(args) {
+                const allTags = [...containerTags, ...(args.tags ?? [])];
+                const result = await client.createMemory(args.content, allTags, args.source, args.scope ?? "project", context.agentId, context.getSessionId(), args.visibility);
+                if (!result)
+                    return JSON.stringify({ ok: false, error: "The omem server may be unavailable." });
+                return JSON.stringify({ ok: true, id: result.id, tags: result.tags });
+            },
+        }),
+        memory_search: tool({
+            description: "Search the user's long-term memory by semantic similarity. " +
+                "Use to recall previously stored preferences, facts, or context.",
+            args: {
+                query: tool.schema.string().describe("Natural-language search query"),
+                limit: tool.schema
+                    .number()
+                    .optional()
+                    .describe("Max results to return (default 10)"),
+                scope: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Optional scope filter"),
+            },
+            async execute(args) {
+                const results = await client.searchMemories(args.query, args.limit ?? 10, args.scope, containerTags);
+                if (results.length === 0)
+                    return JSON.stringify({ ok: true, count: 0, results: [] });
+                const items = results.map((r) => ({
+                    id: r.memory.id,
+                    score: r.score,
+                    content: r.memory.content.slice(0, 200),
+                }));
+                return JSON.stringify({ ok: true, count: results.length, results: items });
+            },
+        }),
+        memory_get: tool({
+            description: "Retrieve a specific memory by its ID.",
+            args: {
+                id: tool.schema.string().describe("Memory ID"),
+            },
+            async execute(args) {
+                const memory = await client.getMemory(args.id);
+                if (!memory)
+                    return JSON.stringify({ ok: false, error: "not found" });
+                return JSON.stringify({ ok: true, memory });
+            },
+        }),
+        memory_update: tool({
+            description: "Update the content or tags of an existing memory. " +
+                "Use when information needs correction or enrichment.",
+            args: {
+                id: tool.schema.string().describe("Memory ID to update"),
+                content: tool.schema.string().describe("New content"),
+                tags: tool.schema
+                    .array(tool.schema.string())
+                    .optional()
+                    .describe("Replacement tags"),
+            },
+            async execute(args) {
+                const result = await client.updateMemory(args.id, args.content, args.tags);
+                if (!result)
+                    return JSON.stringify({ ok: false, error: `Failed to update memory ${args.id}` });
+                return JSON.stringify({ ok: true, id: args.id });
+            },
+        }),
+        memory_profile: tool({
+            description: "Get the user profile synthesized from stored memories. Shows preferences, patterns, and key information.",
+            args: {},
+            async execute() {
+                const profile = await client.getProfile();
+                if (!profile)
+                    return JSON.stringify({ ok: false, error: "Failed to get profile" });
+                return JSON.stringify({ ok: true, profile });
+            },
+        }),
+        memory_list: tool({
+            description: "List the most recent memories. Use to browse what's been remembered without a search query.",
+            args: {
+                limit: tool.schema
+                    .number()
+                    .optional()
+                    .describe("Max memories to return (default: 20)"),
+            },
+            async execute(args) {
+                const memories = await client.listRecent(args.limit ?? 20);
+                if (memories.length === 0)
+                    return JSON.stringify({ ok: true, count: 0, memories: [] });
+                const items = memories.map((m) => ({
+                    id: m.id,
+                    content: m.content.slice(0, 120),
+                    category: m.category,
+                    tags: m.tags,
+                }));
+                return JSON.stringify({ ok: true, count: memories.length, memories: items });
+            },
+        }),
+        session_recalls: tool({
+            description: "List the injection records for a session. Use to see what memories have been recalled into the current session.",
+            args: {
+                session_id: tool.schema
+                    .string()
+                    .describe("Session ID to query recall records for"),
+            },
+            async execute(args) {
+                const recalls = await client.listSessionRecalls(args.session_id);
+                if (recalls.length === 0)
+                    return JSON.stringify({ ok: true, count: 0, recalls: [] });
+                return JSON.stringify({ ok: true, count: recalls.length, recalls });
+            },
+        }),
+        memory_ingest: tool({
+            description: "Ingest conversation messages for intelligent extraction. The system extracts atomic facts, deduplicates, and reconciles with existing memories.",
+            args: {
+                messages: tool.schema
+                    .array(tool.schema.object({
+                    role: tool.schema.string().describe("Message role: user, assistant, or system"),
+                    content: tool.schema.string().describe("Message content"),
+                }))
+                    .describe("Conversation messages to ingest"),
+                mode: tool.schema
+                    .enum(["smart", "raw"])
+                    .optional()
+                    .describe("Extraction mode: 'smart' (default) or 'raw'"),
+                tags: tool.schema
+                    .array(tool.schema.string())
+                    .optional()
+                    .describe("Tags to apply to extracted memories"),
+                session_id: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Session ID to associate with the ingestion"),
+            },
+            async execute(args) {
+                const result = await client.ingestMessages(args.messages, {
+                    mode: args.mode ?? "smart",
+                    tags: args.tags,
+                    sessionId: args.session_id,
+                });
+                if (result === null)
+                    return JSON.stringify({ ok: false, error: "Ingestion failed" });
+                if (args.session_id) {
+                    const memoryIds = extractMemoryIds(result);
+                    if (memoryIds.length > 0) {
+                        await client.recordSessionRecall(args.session_id, memoryIds, "manual", args.messages.map((m) => m.content).join("\n").slice(0, 200), 0, 0).catch(() => { });
+                    }
+                }
+                return JSON.stringify({ ok: true, result });
+            },
+        }),
+        memory_stats: tool({
+            description: "Get statistics about stored memories — counts by category, type, tier, and timeline.",
+            args: {},
+            async execute() {
+                const stats = await client.getStats();
+                if (!stats)
+                    return JSON.stringify({ ok: false, error: "Failed to get stats" });
+                return JSON.stringify({ ok: true, stats });
+            },
+        }),
+        memory_delete: tool({
+            description: "Delete a memory by ID. Use when the user asks to forget something.",
+            args: {
+                id: tool.schema.string().describe("Memory ID to delete"),
+            },
+            async execute(args) {
+                try {
+                    await client.deleteMemory(args.id);
+                    return JSON.stringify({ ok: true, id: args.id });
+                }
+                catch {
+                    return JSON.stringify({ ok: false, error: `Failed to delete memory ${args.id}` });
+                }
+            },
+        }),
+        space_create: tool({
+            description: "Create a shared space (team or organization) for sharing memories across users and agents.",
+            args: {
+                name: tool.schema.string().describe("Name of the space"),
+                space_type: tool.schema
+                    .string()
+                    .describe("Type of space: 'team' or 'organization'"),
+                members: tool.schema
+                    .array(tool.schema.object({
+                    user_id: tool.schema.string().describe("User/tenant ID to add"),
+                    role: tool.schema.string().describe("Member role: admin, member, or reader"),
+                }))
+                    .optional()
+                    .describe("Initial members to add"),
+            },
+            async execute(args) {
+                const result = await client.createSpace(args.name, args.space_type, args.members);
+                if (!result)
+                    return JSON.stringify({ ok: false, error: "Failed to create space" });
+                return JSON.stringify({ ok: true, space: result });
+            },
+        }),
+        space_list: tool({
+            description: "List all spaces you own or are a member of.",
+            args: {},
+            async execute() {
+                const spaces = await client.listSpaces();
+                return JSON.stringify({ ok: true, spaces });
+            },
+        }),
+        space_add_member: tool({
+            description: "Add a user to an existing shared space with a specified role.",
+            args: {
+                space_id: tool.schema.string().describe("Space ID"),
+                user_id: tool.schema.string().describe("User/tenant ID to add"),
+                role: tool.schema.string().describe("Role: admin, member, or reader"),
+            },
+            async execute(args) {
+                const result = await client.addSpaceMember(args.space_id, args.user_id, args.role);
+                if (!result)
+                    return JSON.stringify({ ok: false, error: "Failed to add member" });
+                return JSON.stringify({ ok: true, result });
+            },
+        }),
+        memory_share: tool({
+            description: "Share a memory to a team or organization space. Creates a copy with provenance tracking.",
+            args: {
+                memory_id: tool.schema.string().describe("Memory ID to share"),
+                target_space: tool.schema.string().describe("Target space ID"),
+            },
+            async execute(args) {
+                const result = await client.shareMemory(args.memory_id, args.target_space);
+                if (!result)
+                    return JSON.stringify({ ok: false, error: "Failed to share memory" });
+                return JSON.stringify({ ok: true, result });
+            },
+        }),
+        memory_pull: tool({
+            description: "Pull a shared memory from a team/organization space into your personal space.",
+            args: {
+                memory_id: tool.schema.string().describe("Memory ID to pull"),
+                source_space: tool.schema.string().describe("Source space ID"),
+                visibility: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Visibility of the pulled copy"),
+            },
+            async execute(args) {
+                const result = await client.pullMemory(args.memory_id, args.source_space, args.visibility);
+                if (!result)
+                    return JSON.stringify({ ok: false, error: "Failed to pull memory" });
+                return JSON.stringify({ ok: true, result });
+            },
+        }),
+        memory_reshare: tool({
+            description: "Refresh a stale shared copy with the latest content and vector from the source memory.",
+            args: {
+                memory_id: tool.schema.string().describe("Shared copy memory ID to refresh"),
+                target_space: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Target space containing the copy (optional)"),
+            },
+            async execute(args) {
+                const result = await client.reshareMemory(args.memory_id, args.target_space);
+                if (!result)
+                    return JSON.stringify({ ok: false, error: "Failed to reshare memory" });
+                return JSON.stringify({ ok: true, result });
+            },
+        }),
+        memory_toggle: tool({
+            description: "Toggle Cerebro auto-store ON or OFF for current session. Does NOT affect manual memory_store calls.",
+            args: {
+                state: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Set to 'on' or 'off'. Omit to check current status."),
+            },
+            async execute(args) {
+                const sessionId = context.getSessionId();
+                if (!sessionId)
+                    return JSON.stringify({ ok: false, error: "No active session" });
+                if (args.state === "on") {
+                    setAutoStoreEnabled(sessionId, true);
+                    return JSON.stringify({ ok: true, auto_store: true, message: "Cerebro auto-store: ON" });
+                }
+                else if (args.state === "off") {
+                    setAutoStoreEnabled(sessionId, false);
+                    return JSON.stringify({ ok: true, auto_store: false, message: "Cerebro auto-store: OFF" });
+                }
+                else {
+                    const current = isAutoStoreEnabled(sessionId);
+                    return JSON.stringify({ ok: true, auto_store: current, message: `Cerebro auto-store: ${current ? "ON" : "OFF"}` });
+                }
+            },
+        }),
+    };
+}
+//# sourceMappingURL=tools.js.map