@seanhogg/builderforce-memory-mcp 2026.6.18

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sean Hogg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# @seanhogg/builderforce-memory-mcp
+
+Expose [`@seanhogg/builderforce-memory`](../memory) to any MCP client. One token-saving
+tool core over a pluggable `MemoryBackend`, three transports:
+
+| Transport | Factory | Consumed as | Use when |
+|---|---|---|---|
+| **In-process (Claude Agent SDK)** | `createMemoryMcpServer(backend)` | the returned `type:"sdk"` object | the consuming product is TS and runs `@anthropic-ai/claude-agent-sdk` in-process — lowest latency |
+| **stdio** | `runStdio(backend)` / `npx @seanhogg/builderforce-memory-mcp` | `{ type:"stdio", command, args }` | any language / separate process; decouples the SSM+IndexedDB deps from the consumer |
+| **HTTP (Streamable)** | `createMemoryHttpHandler(backend, { authToken })` | `{ type:"http", url, headers }` | multi-tenant / networked (builderforce.ai hosting, remote claws) |
+
+## Why this saves tokens
+
+The point of an external memory store is **fetch-on-demand** instead of pinning
+your whole memory file into every prompt. That only pays off if recall is
+*selective*, so the caps are enforced server-side in [`tools.ts`](src/tools.ts):
+
+- `memory_recall` returns a **ranked top-K** (default 5, hard-capped), never the store.
+- Each entry's content is **truncated** (default 500 chars) before it hits context.
+- There is **no "return everything" tool** — a dump-all is more expensive than inlining.
+
+Tool descriptions are prescriptive ("call this *before* answering when…") because
+recent Claude models reach for tools more conservatively; the trigger condition in
+the description is what drives should-call rate. Pair this with prompt caching (keep
+the tool set identical across tenants so the cached prefix survives) and context
+editing (prune stale recalled facts) for the full win.
+
+## The seam
+
+Everything is written against [`MemoryBackend`](src/backend.ts):
+
+```ts
+interface MemoryBackend {
+  recall(query: string, topK: number): Promise<RecallHit[]>;  // semantic
+  get(key: string): Promise<RecallHit | undefined>;           // exact
+  recallByTag(tag: string, limit: number): Promise<RecallHit[]>;
+  remember?(input: RememberInput): Promise<void>;             // optional → read-only backends omit
+  forget?(key: string): Promise<void>;
+}
+```
+
+Ship the local `MemoryStoreBackend` (IndexedDB via `@seanhogg/builderforce-memory`) today;
+drop in a networked builderforce.ai adapter later with **zero** changes to tools
+or transports.
+
+## Quick start — in-process with the Claude Agent SDK
+
+```ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { createMemoryMcpServer, createLocalMemoryStoreBackend } from "@seanhogg/builderforce-memory-mcp";
+
+const backend = await createLocalMemoryStoreBackend();          // IndexedDB (fake-indexeddb in Node)
+const memory  = await createMemoryMcpServer(backend);           // type:"sdk" config
+
+for await (const msg of query({
+  prompt: "What language does this user prefer? Check memory first.",
+  options: {
+    mcpServers: { builderforce_memory: memory },
+    allowedTools: ["mcp__builderforce_memory__*"],             // auto-approve, no prompts
+  },
+})) {
+  if (msg.type === "result" && msg.subtype === "success") console.log(msg.result);
+}
+```
+
+### SSM-embedding recall (the premium path)
+
+The local backend defaults to **lexical (Jaccard)** recall. For SSM-embedding
+cosine recall, pass an SSM runtime — e.g. reuse the agent-runtime's already-loaded
+hippocampus instead of standing up a second model:
+
+```ts
+const backend = await createLocalMemoryStoreBackend({ runtime: ssmMemoryService.runtime });
+```
+
+Recall quality then improves automatically as that model is adapted/distilled.
+
+## Quick start — stdio (any process / language)
+
+```bash
+npx -y @seanhogg/builderforce-memory-mcp        # serves the local MemoryStore over stdio
+```
+
+```ts
+mcpServers: {
+  builderforce_memory: { type: "stdio", command: "npx", args: ["-y", "@seanhogg/builderforce-memory-mcp"] },
+}
+```
+
+Env: `BUILDERFORCE_MEMORY_DB` (db name), `BUILDERFORCE_MEMORY_READONLY=1` (drop write tools).
+
+## Quick start — HTTP (multi-tenant)
+
+```bash
+BUILDERFORCE_MEMORY_TOKEN=secret PORT=8787 npx @seanhogg/builderforce-memory-mcp-http
+```
+
+```ts
+mcpServers: {
+  builderforce_memory: {
+    type: "http",
+    url: "http://localhost:8787",
+    headers: { Authorization: "Bearer secret" },
+  },
+}
+```
+
+Or mount `createMemoryHttpHandler(backend, { authToken })` on your own Node/Express
+server against any backend (including a future remote one).
+
+## Custom / remote backend
+
+Implement `MemoryBackend` and hand it to any transport:
+
+```ts
+import { createMemoryMcpServer, type MemoryBackend } from "@seanhogg/builderforce-memory-mcp";
+
+const remote: MemoryBackend = {
+  recall:      (q, k)   => bfClient.search(q, k),
+  get:         (key)    => bfClient.get(key),
+  recallByTag: (t, lim) => bfClient.byTag(t, lim),
+  remember:    (input)  => bfClient.put(input),
+  forget:      (key)    => bfClient.delete(key),
+};
+const server = await createMemoryMcpServer(remote);
+```
+
+## Dependencies
+
+`@modelcontextprotocol/sdk` + `zod` are hard deps. `@anthropic-ai/claude-agent-sdk`
+(SDK transport), `@seanhogg/builderforce-memory` + `fake-indexeddb` (local backend) are
+**optional peers**, imported indirectly — install only what your transport/backend
+needs.

package/dist/backend.d.ts

@@ -0,0 +1,60 @@
+/**
+ * MemoryBackend — the storage seam every transport is written against.
+ *
+ * The MCP tools (src/tools.ts) and all three transports (SDK / stdio / HTTP)
+ * depend ONLY on this interface, never on a concrete store. Ship the local
+ * `MemoryStoreBackend` (IndexedDB via @seanhogg/builderforce-memory) today; drop in a
+ * networked builderforce.ai adapter later with zero changes to the tools or
+ * transports.
+ */
+/** A single recalled memory, normalised across backends. */
+export interface RecallHit {
+    /** Stable identifier for the memory. */
+    key: string;
+    /** The stored value. */
+    content: string;
+    /**
+     * Optional relevance score (higher = closer). Semantic backends that expose
+     * ranking can populate this; the local MemoryStore ranks but does not surface
+     * a score, so it is left undefined and recall order carries the signal.
+     */
+    score?: number;
+    /** Tags for grouping/filtering. */
+    tags?: string[];
+    /** Importance weight 0–1. */
+    importance?: number;
+    /** Unix-ms write time. */
+    timestamp?: number;
+}
+/** Arguments for writing a memory. */
+export interface RememberInput {
+    key: string;
+    content: string;
+    tags?: string[];
+    /** Importance weight 0–1. */
+    importance?: number;
+    /** Time-to-live in milliseconds. */
+    ttlMs?: number;
+}
+/**
+ * The minimal capability surface the MCP layer needs. Deliberately small —
+ * the token-saving design exposes recall-on-demand, not a "dump everything"
+ * call, so this interface has no `recallAll`.
+ */
+export interface MemoryBackend {
+    /**
+     * Semantic top-K recall. Backends with an embedding model (the SSM
+     * runtime) should use it; lexical fallback is acceptable. `topK` is already
+     * clamped by the caller — the backend may return fewer, never more.
+     */
+    recall(query: string, topK: number): Promise<RecallHit[]>;
+    /** Exact lookup by key. Returns undefined when absent or expired. */
+    get(key: string): Promise<RecallHit | undefined>;
+    /** All non-expired entries carrying `tag`, capped to `limit`. */
+    recallByTag(tag: string, limit: number): Promise<RecallHit[]>;
+    /** Store or overwrite a memory. Optional — read-only backends omit it. */
+    remember?(input: RememberInput): Promise<void>;
+    /** Delete a memory by key. Optional — read-only backends omit it. */
+    forget?(key: string): Promise<void>;
+}
+//# sourceMappingURL=backend.d.ts.map

package/dist/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../src/backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,4DAA4D;AAC5D,MAAM,WAAW,SAAS;IACtB,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,sCAAsC;AACtC,MAAM,WAAW,aAAa;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAE1D,qEAAqE;IACrE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IAEjD,iEAAiE;IACjE,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAE9D,0EAA0E;IAC1E,QAAQ,CAAC,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/C,qEAAqE;IACrE,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC"}

package/dist/backend.js

@@ -0,0 +1,11 @@
+/**
+ * MemoryBackend — the storage seam every transport is written against.
+ *
+ * The MCP tools (src/tools.ts) and all three transports (SDK / stdio / HTTP)
+ * depend ONLY on this interface, never on a concrete store. Ship the local
+ * `MemoryStoreBackend` (IndexedDB via @seanhogg/builderforce-memory) today; drop in a
+ * networked builderforce.ai adapter later with zero changes to the tools or
+ * transports.
+ */
+export {};
+//# sourceMappingURL=backend.js.map

package/dist/backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.js","sourceRoot":"","sources":["../src/backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/backends/memory-store.d.ts

@@ -0,0 +1,73 @@
+/**
+ * MemoryStoreBackend — local adapter mapping @seanhogg/builderforce-memory's MemoryStore
+ * onto the MemoryBackend seam.
+ *
+ * Recall quality: when an SSM runtime is supplied it is forwarded to
+ * `recallSimilar`, so recall uses SSM-embedding cosine similarity and improves
+ * as the model is adapted/distilled. With no runtime it transparently falls
+ * back to Jaccard word-overlap (still useful, just lexical).
+ */
+import type { MemoryBackend, RecallHit, RememberInput } from "../backend.js";
+interface MemoryEntryLike {
+    key: string;
+    content: string;
+    timestamp?: number;
+    tags?: string[];
+    importance?: number;
+}
+interface MemoryStoreLike {
+    remember(key: string, content: string, opts?: {
+        ttlMs?: number;
+        tags?: string[];
+        importance?: number;
+    }): Promise<void>;
+    recall(key: string): Promise<MemoryEntryLike | undefined>;
+    recallAll(): Promise<MemoryEntryLike[]>;
+    recallByTag(tag: string): Promise<MemoryEntryLike[]>;
+    recallSimilar(query: string, topK: number, runtime?: unknown): Promise<MemoryEntryLike[]>;
+    forget(key: string): Promise<void>;
+}
+export declare class MemoryStoreBackend implements MemoryBackend {
+    private readonly store;
+    /** Optional SSMRuntime; enables embedding-based recall when present. */
+    private readonly runtime?;
+    constructor(store: MemoryStoreLike, 
+    /** Optional SSMRuntime; enables embedding-based recall when present. */
+    runtime?: unknown | undefined);
+    recall(query: string, topK: number): Promise<RecallHit[]>;
+    get(key: string): Promise<RecallHit | undefined>;
+    recallByTag(tag: string, limit: number): Promise<RecallHit[]>;
+    remember(input: RememberInput): Promise<void>;
+    forget(key: string): Promise<void>;
+}
+/** Options for {@link createLocalMemoryStoreBackend}. */
+export interface LocalBackendOptions {
+    /** IndexedDB database name. Defaults to MemoryStore's own default ('ssmjs'). */
+    dbName?: string;
+    /**
+     * Optional SSMRuntime for embedding-based recall. Omit for lexical (Jaccard)
+     * recall. In the agent-runtime, pass `ssmMemoryService.runtime` here to reuse
+     * the already-loaded hippocampus instead of standing up a second model.
+     */
+    runtime?: unknown;
+    /**
+     * Absolute path to a JSON file that mirrors the store to disk. Without it the
+     * store is purely in-memory (fake-indexeddb) and evaporates when the process
+     * exits — fine for a long-lived server, fatal for a per-session subprocess
+     * (e.g. an MCP stdio client that respawns the server each launch).
+     *
+     * When set, the store is hydrated from the file on creation and re-snapshotted
+     * after every remember/forget, giving durable cross-process memory. TTLs are
+     * dropped on persist: the snapshot is the durable long-term tier.
+     */
+    persistFile?: string;
+}
+/**
+ * Builds a MemoryStoreBackend over a fresh MemoryStore, wiring fake-indexeddb in
+ * Node exactly as SsmMemoryService does. @seanhogg/builderforce-memory and fake-indexeddb
+ * are imported indirectly so they remain optional peers — a consumer that only
+ * wants a custom backend (or the HTTP thin-client) never has to install them.
+ */
+export declare function createLocalMemoryStoreBackend(opts?: LocalBackendOptions): Promise<MemoryBackend>;
+export {};
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/backends/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../../src/backends/memory-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAI7E,UAAU,eAAe;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,eAAe;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAAC;IAC1D,SAAS,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IACxC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IACrD,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAC1F,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAYD,qBAAa,kBAAmB,YAAW,aAAa;IAEhD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAFR,KAAK,EAAE,eAAe;IACvC,wEAAwE;IACvD,OAAO,CAAC,EAAE,OAAO,YAAA;IAGhC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAKzD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAKhD,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAK7D,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ7C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG3C;AAED,yDAAyD;AACzD,MAAM,WAAW,mBAAmB;IAChC,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAiFD;;;;;GAKG;AACH,wBAAsB,6BAA6B,CAAC,IAAI,GAAE,mBAAwB,GAAG,OAAO,CAAC,aAAa,CAAC,CAgC1G"}

package/dist/backends/memory-store.js

@@ -0,0 +1,152 @@
+/**
+ * MemoryStoreBackend — local adapter mapping @seanhogg/builderforce-memory's MemoryStore
+ * onto the MemoryBackend seam.
+ *
+ * Recall quality: when an SSM runtime is supplied it is forwarded to
+ * `recallSimilar`, so recall uses SSM-embedding cosine similarity and improves
+ * as the model is adapted/distilled. With no runtime it transparently falls
+ * back to Jaccard word-overlap (still useful, just lexical).
+ */
+function toHit(e) {
+    return {
+        key: e.key,
+        content: e.content,
+        tags: e.tags,
+        importance: e.importance,
+        timestamp: e.timestamp,
+    };
+}
+export class MemoryStoreBackend {
+    store;
+    runtime;
+    constructor(store, 
+    /** Optional SSMRuntime; enables embedding-based recall when present. */
+    runtime) {
+        this.store = store;
+        this.runtime = runtime;
+    }
+    async recall(query, topK) {
+        const entries = await this.store.recallSimilar(query, topK, this.runtime);
+        return entries.map(toHit);
+    }
+    async get(key) {
+        const e = await this.store.recall(key);
+        return e ? toHit(e) : undefined;
+    }
+    async recallByTag(tag, limit) {
+        const entries = await this.store.recallByTag(tag);
+        return entries.slice(0, limit).map(toHit);
+    }
+    async remember(input) {
+        await this.store.remember(input.key, input.content, {
+            ttlMs: input.ttlMs,
+            tags: input.tags,
+            importance: input.importance,
+        });
+    }
+    async forget(key) {
+        await this.store.forget(key);
+    }
+}
+/**
+ * Wraps a MemoryStoreBackend so every write is mirrored to a JSON file, and
+ * hydrates that file back into the store on boot. This is what turns a respawned
+ * stdio subprocess into a persistent memory: the store itself is in-memory, the
+ * file is the source of truth across process lifetimes.
+ */
+class DiskPersistedBackend {
+    inner;
+    store;
+    file;
+    fs;
+    constructor(inner, store, file, fs) {
+        this.inner = inner;
+        this.store = store;
+        this.file = file;
+        this.fs = fs;
+    }
+    recall(query, topK) {
+        return this.inner.recall(query, topK);
+    }
+    get(key) {
+        return this.inner.get(key);
+    }
+    recallByTag(tag, limit) {
+        return this.inner.recallByTag(tag, limit);
+    }
+    async remember(input) {
+        await this.inner.remember(input);
+        await this.snapshot();
+    }
+    async forget(key) {
+        await this.inner.forget(key);
+        await this.snapshot();
+    }
+    async snapshot() {
+        const entries = await this.store.recallAll();
+        const out = entries.map((e) => ({
+            key: e.key,
+            content: e.content,
+            tags: e.tags,
+            importance: e.importance,
+        }));
+        this.fs.writeFileSync(this.file, JSON.stringify(out, null, 2));
+    }
+}
+/** Reads a snapshot file and replays it into the store as durable (no-TTL) entries. */
+async function hydrateFromDisk(store, file, fs) {
+    if (!fs.existsSync(file))
+        return;
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        // Corrupt/partial snapshot — start clean rather than crash the server.
+        return;
+    }
+    if (!Array.isArray(parsed))
+        return;
+    for (const raw of parsed) {
+        if (!raw || typeof raw.key !== "string" || typeof raw.content !== "string")
+            continue;
+        await store.remember(raw.key, raw.content, { tags: raw.tags, importance: raw.importance });
+    }
+}
+/**
+ * Builds a MemoryStoreBackend over a fresh MemoryStore, wiring fake-indexeddb in
+ * Node exactly as SsmMemoryService does. @seanhogg/builderforce-memory and fake-indexeddb
+ * are imported indirectly so they remain optional peers — a consumer that only
+ * wants a custom backend (or the HTTP thin-client) never has to install them.
+ */
+export async function createLocalMemoryStoreBackend(opts = {}) {
+    // Indirect import prevents the bundler/tsc from resolving optional peers.
+    const _import = (m) => 
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
+    new Function("m", "return import(m)")(m);
+    const memoryMod = (await _import("@seanhogg/builderforce-memory"));
+    const { MemoryStore } = memoryMod;
+    // IndexedDB shim for Node. In the browser the global is used automatically.
+    let idbFactory;
+    try {
+        const fake = (await _import("fake-indexeddb"));
+        idbFactory = new fake.IDBFactory();
+    }
+    catch {
+        // Browser or a host that provides global indexedDB — MemoryStore handles it.
+    }
+    const store = new MemoryStore({ idbFactory, dbName: opts.dbName });
+    const backend = new MemoryStoreBackend(store, opts.runtime);
+    if (!opts.persistFile)
+        return backend;
+    // Disk-mirror requested. node:fs/path are loaded indirectly so a browser
+    // bundle of this module never statically pulls in Node builtins.
+    const fs = (await _import("node:fs"));
+    const path = (await _import("node:path"));
+    const dir = path.dirname(opts.persistFile);
+    if (dir && !fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    await hydrateFromDisk(store, opts.persistFile, fs);
+    return new DiskPersistedBackend(backend, store, opts.persistFile, fs);
+}
+//# sourceMappingURL=memory-store.js.map

package/dist/backends/memory-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.js","sourceRoot":"","sources":["../../src/backends/memory-store.ts"],"names":[],"mappings":"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"}

package/dist/bin/http.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * `builderforce-memory-mcp-http` — Streamable HTTP MCP server over the LOCAL
+ * MemoryStore. A reference host; in production builderforce.ai would mount
+ * createMemoryHttpHandler() against a shared/remote backend instead.
+ *
+ * Env:
+ *   PORT                          Listen port (default 8787).
+ *   BUILDERFORCE_MEMORY_TOKEN     Bearer token required on every request (recommended).
+ *   BUILDERFORCE_MEMORY_DB        IndexedDB database name.
+ *   BUILDERFORCE_MEMORY_READONLY  '1' to disable remember/forget tools.
+ */
+export {};
+//# sourceMappingURL=http.d.ts.map

package/dist/bin/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/bin/http.ts"],"names":[],"mappings":";AACA;;;;;;;;;;GAUG"}

package/dist/bin/http.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * `builderforce-memory-mcp-http` — Streamable HTTP MCP server over the LOCAL
+ * MemoryStore. A reference host; in production builderforce.ai would mount
+ * createMemoryHttpHandler() against a shared/remote backend instead.
+ *
+ * Env:
+ *   PORT                          Listen port (default 8787).
+ *   BUILDERFORCE_MEMORY_TOKEN     Bearer token required on every request (recommended).
+ *   BUILDERFORCE_MEMORY_DB        IndexedDB database name.
+ *   BUILDERFORCE_MEMORY_READONLY  '1' to disable remember/forget tools.
+ */
+import http from "node:http";
+import { createLocalMemoryStoreBackend } from "../backends/memory-store.js";
+import { createMemoryHttpHandler } from "../transports/http.js";
+const backend = await createLocalMemoryStoreBackend({
+    dbName: process.env["BUILDERFORCE_MEMORY_DB"],
+});
+const handler = createMemoryHttpHandler(backend, {
+    authToken: process.env["BUILDERFORCE_MEMORY_TOKEN"],
+    writable: process.env["BUILDERFORCE_MEMORY_READONLY"] !== "1",
+});
+const port = Number(process.env["PORT"] ?? 8787);
+http.createServer((req, res) => {
+    void handler(req, res).catch((err) => {
+        if (!res.headersSent)
+            res.writeHead(500, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: String(err) }));
+    });
+}).listen(port, () => {
+    process.stderr.write(`[builderforce-memory-mcp-http] listening on :${port}\n`);
+});
+//# sourceMappingURL=http.js.map

package/dist/bin/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","sourceRoot":"","sources":["../../src/bin/http.ts"],"names":[],"mappings":";AACA;;;;;;;;;;GAUG;AAEH,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,MAAM,OAAO,GAAG,MAAM,6BAA6B,CAAC;IAChD,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC;CAChD,CAAC,CAAC;AAEH,MAAM,OAAO,GAAG,uBAAuB,CAAC,OAAO,EAAE;IAC7C,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC;IACnD,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,KAAK,GAAG;CAChE,CAAC,CAAC;AAEH,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;AAEjD,IAAI,CAAC,YAAY,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;IAC3B,KAAK,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;QACjC,IAAI,CAAC,GAAG,CAAC,WAAW;YAAE,GAAG,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC,CAAC;QACjF,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE;IACjB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,gDAAgD,IAAI,IAAI,CAAC,CAAC;AACnF,CAAC,CAAC,CAAC"}

package/dist/bin/stdio.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * `builderforce-memory-mcp` — stdio MCP server over the LOCAL MemoryStore.
+ *
+ * Env:
+ *   BUILDERFORCE_MEMORY_DB        IndexedDB database name (default: MemoryStore default).
+ *   BUILDERFORCE_MEMORY_READONLY  '1' to disable remember/forget tools.
+ *   BUILDERFORCE_MEMORY_FILE      Absolute path to a JSON snapshot. When set, memory
+ *                                 persists across process restarts — REQUIRED for an
+ *                                 MCP client that respawns this server each session
+ *                                 (otherwise fake-indexeddb loses everything on exit).
+ *
+ * Recall is lexical (Jaccard) here — this headless binary does not stand up the
+ * SSM runtime/GPU. For SSM-embedding recall, embed the package in-process and
+ * pass `runtime` to createLocalMemoryStoreBackend (see README).
+ */
+export {};
+//# sourceMappingURL=stdio.d.ts.map

package/dist/bin/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/bin/stdio.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;GAcG"}

package/dist/bin/stdio.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * `builderforce-memory-mcp` — stdio MCP server over the LOCAL MemoryStore.
+ *
+ * Env:
+ *   BUILDERFORCE_MEMORY_DB        IndexedDB database name (default: MemoryStore default).
+ *   BUILDERFORCE_MEMORY_READONLY  '1' to disable remember/forget tools.
+ *   BUILDERFORCE_MEMORY_FILE      Absolute path to a JSON snapshot. When set, memory
+ *                                 persists across process restarts — REQUIRED for an
+ *                                 MCP client that respawns this server each session
+ *                                 (otherwise fake-indexeddb loses everything on exit).
+ *
+ * Recall is lexical (Jaccard) here — this headless binary does not stand up the
+ * SSM runtime/GPU. For SSM-embedding recall, embed the package in-process and
+ * pass `runtime` to createLocalMemoryStoreBackend (see README).
+ */
+import { createLocalMemoryStoreBackend } from "../backends/memory-store.js";
+import { runStdio } from "../transports/stdio.js";
+const backend = await createLocalMemoryStoreBackend({
+    dbName: process.env["BUILDERFORCE_MEMORY_DB"],
+    persistFile: process.env["BUILDERFORCE_MEMORY_FILE"],
+});
+await runStdio(backend, { writable: process.env["BUILDERFORCE_MEMORY_READONLY"] !== "1" });
+//# sourceMappingURL=stdio.js.map

package/dist/bin/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["../../src/bin/stdio.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAElD,MAAM,OAAO,GAAG,MAAM,6BAA6B,CAAC;IAChD,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC;IAC7C,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;CACvD,CAAC,CAAC;AAEH,MAAM,QAAQ,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @seanhogg/builderforce-memory-mcp — expose @seanhogg/builderforce-memory to MCP clients.
+ *
+ * One token-saving tool core over a pluggable MemoryBackend, three transports:
+ *   - createMemoryMcpServer  → in-process Claude Agent SDK (type:"sdk")
+ *   - runStdio               → stdio subprocess (any language)
+ *   - createMemoryHttpHandler→ Streamable HTTP (multi-tenant / networked)
+ */
+export type { MemoryBackend, RecallHit, RememberInput } from "./backend.js";
+export { MemoryStoreBackend, createLocalMemoryStoreBackend } from "./backends/memory-store.js";
+export type { LocalBackendOptions } from "./backends/memory-store.js";
+export { buildMemoryTools } from "./tools.js";
+export type { MemoryTool, MemoryToolsOptions, ToolResult } from "./tools.js";
+export { createMemoryMcpServer } from "./transports/sdk.js";
+export type { SdkServerOptions, SdkMcpServerConfig } from "./transports/sdk.js";
+export { buildMcpServer } from "./transports/mcp-server.js";
+export type { McpServerOptions } from "./transports/mcp-server.js";
+export { runStdio } from "./transports/stdio.js";
+export { createMemoryHttpHandler } from "./transports/http.js";
+export type { HttpHandlerOptions } from "./transports/http.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG5E,OAAO,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAC/F,YAAY,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEhF,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+/**
+ * @seanhogg/builderforce-memory-mcp — expose @seanhogg/builderforce-memory to MCP clients.
+ *
+ * One token-saving tool core over a pluggable MemoryBackend, three transports:
+ *   - createMemoryMcpServer  → in-process Claude Agent SDK (type:"sdk")
+ *   - runStdio               → stdio subprocess (any language)
+ *   - createMemoryHttpHandler→ Streamable HTTP (multi-tenant / networked)
+ */
+// ── Local backend (IndexedDB via @seanhogg/builderforce-memory) ────────────────────────
+export { MemoryStoreBackend, createLocalMemoryStoreBackend } from "./backends/memory-store.js";
+// ── Tool core ─────────────────────────────────────────────────────────────────
+export { buildMemoryTools } from "./tools.js";
+// ── Transports ──────────────────────────────────────────────────────────────
+export { createMemoryMcpServer } from "./transports/sdk.js";
+export { buildMcpServer } from "./transports/mcp-server.js";
+export { runStdio } from "./transports/stdio.js";
+export { createMemoryHttpHandler } from "./transports/http.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,0FAA0F;AAC1F,OAAO,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAG/F,iFAAiF;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG9C,+EAA+E;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC"}