diff --git a/package-lock.json b/package-lock.json index 185f994..dbd07c8 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1802,6 +1802,13 @@ "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", "license": "MIT" }, + "node_modules/@cloudflare/workers-types": { + "version": "4.20260702.1", + "resolved": "https://registry.npmjs.org/@cloudflare/workers-types/-/workers-types-4.20260702.1.tgz", + "integrity": "sha512-mOhf5TUEB1m2vPrxtqoIGfz0fUC9xyxRDx5gWHy5s+OCo6dcV+g7wI1R7gYCMFohhqF/2y2xeKVwMwCJjfn/WA==", + "license": "MIT OR Apache-2.0", + "peer": true + }, "node_modules/@date-fns/tz": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/@date-fns/tz/-/tz-1.5.0.tgz", @@ -7992,6 +7999,16 @@ "undici-types": "~6.21.0" } }, + "node_modules/@types/node-fetch": { + "version": "2.6.13", + "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.13.tgz", + "integrity": "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "form-data": "^4.0.4" + } + }, "node_modules/@types/pdfkit": { "version": "0.17.6", "resolved": "https://registry.npmjs.org/@types/pdfkit/-/pdfkit-0.17.6.tgz", @@ -8903,6 +8920,14 @@ "resolved": "packages/marketplace", "link": true }, + "node_modules/@waggle/memory-contract": { + "resolved": "packages/memory-contract", + "link": true + }, + "node_modules/@waggle/memory-mem0": { + "resolved": "packages/memory-mem0", + "link": true + }, "node_modules/@waggle/optimizer": { "resolved": "packages/optimizer", "link": true @@ -9152,7 +9177,6 @@ "version": "6.0.2", "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", - "dev": true, "license": "MIT", "dependencies": { "debug": "4" @@ -9161,6 +9185,18 @@ "node": ">= 6.0.0" } }, + "node_modules/agentkeepalive": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz", + "integrity": "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==", + "license": "MIT", + "dependencies": { + "humanize-ms": "^1.2.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, "node_modules/ajv": { "version": "6.15.0", "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz", @@ -9635,7 +9671,6 @@ "version": "0.4.0", "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", - "dev": true, "license": "MIT" }, "node_modules/atomic-sleep": { @@ -9730,6 +9765,18 @@ "node": ">=4" } }, + "node_modules/axios": { + "version": "1.20.0", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.20.0.tgz", + "integrity": "sha512-r8aOh8j9cGKpgQAqpzrUHnSIc6a59Y3Xf/cv8sy1DrHCkZHzQGEuoq1tARk6qSyDdtQGSDgpb9kFlruzPvrgwg==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.16.0", + "form-data": "^4.0.6", + "https-proxy-agent": "^5.0.1", + "proxy-from-env": "^2.1.0" + } + }, "node_modules/axobject-query": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz", @@ -10740,7 +10787,6 @@ "version": "1.0.8", "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", - "dev": true, "license": "MIT", "dependencies": { "delayed-stream": "~1.0.0" @@ -10784,6 +10830,21 @@ "node": ">= 14" } }, + "node_modules/compromise": { + "version": "14.18.0", + "resolved": "https://registry.npmjs.org/compromise/-/compromise-14.18.0.tgz", + "integrity": "sha512-SCNTeMZN8ZnvDz96igAjV2QuvvmcKA1bVDbFr8IH672Ec9w+fTSxixIPGgrlivaxU+jyk/Ei3AT3gGtP23n6Vg==", + "license": "MIT", + "peer": true, + "dependencies": { + "efrt": "2.9.0", + "grad-school": "0.0.9", + "suffix-thumb": "6.0.0" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", @@ -11372,7 +11433,6 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", - "dev": true, "license": "MIT", "engines": { "node": ">=0.4.0" @@ -11912,6 +11972,16 @@ "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", "license": "MIT" }, + "node_modules/efrt": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/efrt/-/efrt-2.9.0.tgz", + "integrity": "sha512-ZMAvlcu4AfmtJ4K/0hs0uofVUZPSeLG/w4yOyZawQLl9YEy8iDKIxIIPsUAlS907clC7bgD17e73vi5unwNE/g==", + "license": "MIT", + "peer": true, + "engines": { + "node": ">=12.0.0" + } + }, "node_modules/electron-to-chromium": { "version": "1.5.364", "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.364.tgz", @@ -12134,7 +12204,6 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", - "dev": true, "license": "MIT", "dependencies": { "es-errors": "^1.3.0", @@ -13899,6 +13968,26 @@ "dev": true, "license": "ISC" }, + "node_modules/follow-redirects": { + "version": "1.16.1", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.16.1.tgz", + "integrity": "sha512-FNvFGzoMLWmE6Yj9spb/zjd7yiNCHiAW9/Tg9CXrQ8wuu32HtlJOwWO11OJafl5FfY3DxTdQ0vj42zU1kvv5jg==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, "node_modules/fontkit": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/fontkit/-/fontkit-2.0.4.tgz", @@ -13952,7 +14041,6 @@ "version": "4.0.6", "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.6.tgz", "integrity": "sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==", - "dev": true, "license": "MIT", "dependencies": { "asynckit": "^0.4.0", @@ -13965,6 +14053,25 @@ "node": ">= 6" } }, + "node_modules/form-data-encoder": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-1.7.2.tgz", + "integrity": "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==", + "license": "MIT" + }, + "node_modules/formdata-node": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/formdata-node/-/formdata-node-4.4.1.tgz", + "integrity": "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==", + "license": "MIT", + "dependencies": { + "node-domexception": "1.0.0", + "web-streams-polyfill": "4.0.0-beta.3" + }, + "engines": { + "node": ">= 12.20" + } + }, "node_modules/forwarded": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", @@ -14344,6 +14451,16 @@ "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", "license": "ISC" }, + "node_modules/grad-school": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/grad-school/-/grad-school-0.0.9.tgz", + "integrity": "sha512-/aoG9CJz/1gB7x5XKp9i7ggA4k+MqZD7Neph3crfrOLWERkeJFXDXzNefvPW0j97iGTNYqTL+rpBEcz83MTmZw==", + "license": "MIT", + "peer": true, + "engines": { + "node": ">=12" + } + }, "node_modules/guid-typescript": { "version": "1.0.9", "resolved": "https://registry.npmjs.org/guid-typescript/-/guid-typescript-1.0.9.tgz", @@ -14417,7 +14534,6 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", - "dev": true, "license": "MIT", "dependencies": { "has-symbols": "^1.0.3" @@ -14604,7 +14720,6 @@ "version": "5.0.1", "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", - "dev": true, "license": "MIT", "dependencies": { "agent-base": "6", @@ -14614,6 +14729,15 @@ "node": ">= 6" } }, + "node_modules/humanize-ms": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", + "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.0.0" + } + }, "node_modules/iconv-lite": { "version": "0.6.3", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", @@ -17564,7 +17688,6 @@ "version": "1.52.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", - "dev": true, "license": "MIT", "engines": { "node": ">= 0.6" @@ -17574,7 +17697,6 @@ "version": "2.1.35", "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", - "dev": true, "license": "MIT", "dependencies": { "mime-db": "1.52.0" @@ -18022,6 +18144,26 @@ "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==", "license": "MIT" }, + "node_modules/node-domexception": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz", + "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==", + "deprecated": "Use your platform's native DOMException instead", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/jimmywarting" + }, + { + "type": "github", + "url": "https://paypal.me/jimmywarting" + } + ], + "license": "MIT", + "engines": { + "node": ">=10.5.0" + } + }, "node_modules/node-exports-info": { "version": "1.6.0", "resolved": "https://registry.npmjs.org/node-exports-info/-/node-exports-info-1.6.0.tgz", @@ -18051,6 +18193,48 @@ "semver": "bin/semver.js" } }, + "node_modules/node-fetch": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", + "license": "MIT", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/node-fetch/node_modules/tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", + "license": "MIT" + }, + "node_modules/node-fetch/node_modules/webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", + "license": "BSD-2-Clause" + }, + "node_modules/node-fetch/node_modules/whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "license": "MIT", + "dependencies": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, "node_modules/node-gyp-build-optional-packages": { "version": "5.2.2", "resolved": "https://registry.npmjs.org/node-gyp-build-optional-packages/-/node-gyp-build-optional-packages-5.2.2.tgz", @@ -18326,6 +18510,51 @@ "integrity": "sha512-vDJMkfCfb0b1A836rgHj+ORuZf4B4+cc2bASQtpeoJLueuFc5DuYwjIZUBrSvx/fO5IrLjLz+oTrB3pcGlhovQ==", "license": "MIT" }, + "node_modules/openai": { + "version": "4.104.0", + "resolved": "https://registry.npmjs.org/openai/-/openai-4.104.0.tgz", + "integrity": "sha512-p99EFNsA/yX6UhVO93f5kJsDRLAg+CTA2RBqdHK4RtK8u5IJw32Hyb2dTGKbnnFmnuoBv5r7Z2CURI9sGZpSuA==", + "license": "Apache-2.0", + "dependencies": { + "@types/node": "^18.11.18", + "@types/node-fetch": "^2.6.4", + "abort-controller": "^3.0.0", + "agentkeepalive": "^4.2.1", + "form-data-encoder": "1.7.2", + "formdata-node": "^4.3.2", + "node-fetch": "^2.6.7" + }, + "bin": { + "openai": "bin/cli" + }, + "peerDependencies": { + "ws": "^8.18.0", + "zod": "^3.23.8" + }, + "peerDependenciesMeta": { + "ws": { + "optional": true + }, + "zod": { + "optional": true + } + } + }, + "node_modules/openai/node_modules/@types/node": { + "version": "18.19.130", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz", + "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==", + "license": "MIT", + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/openai/node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "license": "MIT" + }, "node_modules/option": { "version": "0.2.4", "resolved": "https://registry.npmjs.org/option/-/option-0.2.4.tgz", @@ -19272,6 +19501,15 @@ "node": ">= 0.10" } }, + "node_modules/proxy-from-env": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz", + "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, "node_modules/psl": { "version": "1.15.0", "resolved": "https://registry.npmjs.org/psl/-/psl-1.15.0.tgz", @@ -21450,6 +21688,16 @@ "node": ">=16 || 14 >=14.17" } }, + "node_modules/suffix-thumb": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/suffix-thumb/-/suffix-thumb-6.0.0.tgz", + "integrity": "sha512-HsCTMLaupbob5ZG//ZW6PSj446tHT5kSJ1qXS5F/qO2Nt13uAn6ZLPhJQ/H6bN/jVQCb+pcqe2psEwy4Mp5+Vw==", + "license": "MIT", + "peer": true, + "engines": { + "node": ">=18" + } + }, "node_modules/supports-color": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", @@ -23109,6 +23357,15 @@ "resolved": "apps/www", "link": true }, + "node_modules/web-streams-polyfill": { + "version": "4.0.0-beta.3", + "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz", + "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==", + "license": "MIT", + "engines": { + "node": ">= 14" + } + }, "node_modules/web-vitals": { "version": "5.3.0", "resolved": "https://registry.npmjs.org/web-vitals/-/web-vitals-5.3.0.tgz", @@ -24605,6 +24862,11 @@ "undici-types": "~6.21.0" } }, + "packages/memory-contract": { + "name": "@waggle/memory-contract", + "version": "0.1.0", + "license": "MIT" + }, "packages/memory-mcp": { "name": "waggle-memory-mcp", "version": "0.1.0", @@ -24627,6 +24889,238 @@ "node": ">=20.0.0" } }, + "packages/memory-mem0": { + "name": "@waggle/memory-mem0", + "version": "0.1.0", + "license": "MIT", + "dependencies": { + "@waggle/memory-contract": "*", + "mem0ai": "3.3.1" + } + }, + "packages/memory-mem0/node_modules/@anthropic-ai/sdk": { + "version": "0.40.1", + "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.40.1.tgz", + "integrity": "sha512-DJMWm8lTEM9Lk/MSFL+V+ugF7jKOn0M2Ujvb5fN8r2nY14aHbGPZ1k6sgjL+tpJ3VuOGJNG+4R83jEpOuYPv8w==", + "license": "MIT", + "optional": true, + "peer": true, + "dependencies": { + "@types/node": "^18.11.18", + "@types/node-fetch": "^2.6.4", + "abort-controller": "^3.0.0", + "agentkeepalive": "^4.2.1", + "form-data-encoder": "1.7.2", + "formdata-node": "^4.3.2", + "node-fetch": "^2.6.7" + } + }, + "packages/memory-mem0/node_modules/@types/node": { + "version": "18.19.130", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz", + "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==", + "license": "MIT", + "optional": true, + "peer": true, + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "packages/memory-mem0/node_modules/mem0ai": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/mem0ai/-/mem0ai-3.3.1.tgz", + "integrity": "sha512-R+T0rB8WNU4Eh8ClfZnD2BKjk7Q4MDx3XdLZMoUZ+S7dItpkpg3xkcGrKqk0COV0dyRrul/EYzkDWTr2D6YTag==", + "license": "Apache-2.0", + "dependencies": { + "axios": "^1.18.0", + "openai": "^4.93.0", + "uuid": "^11.1.1", + "zod": "^3.24.1" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@anthropic-ai/sdk": "^0.40.1", + "@aws-sdk/client-bedrock-runtime": ">=3.0.0 <3.968.0", + "@aws-sdk/client-neptune-graph": ">=3.0.0 <3.968.0", + "@aws-sdk/client-s3vectors": "3.967.0", + "@azure/identity": "^4.0.0", + "@azure/search-documents": "^12.0.0", + "@cloudflare/workers-types": "^4.20250504.0", + "@databricks/sql": "^1.16.0", + "@elastic/elasticsearch": "^9.0.0", + "@google-cloud/aiplatform": "^6.8.0", + "@google/genai": "^1.40.0", + "@huggingface/transformers": "^3.0.0 || ^4.0.0", + "@langchain/core": "^1.1.47", + "@mistralai/mistralai": "^1.5.2", + "@mochow/mochow-sdk-node": "^2.1.5", + "@opensearch-project/opensearch": "^3.5.1", + "@pinecone-database/pinecone": "^8.0.0", + "@qdrant/js-client-rest": "^1.18.0", + "@supabase/supabase-js": "^2.49.1", + "@turbopuffer/turbopuffer": "^2.0.0", + "@types/pg": "^8.11.0", + "@upstash/vector": "^1.2.3", + "@zilliz/milvus2-sdk-node": "^2.4.0 || ^3.0.0", + "better-sqlite3": "^12.6.2", + "cassandra-driver": "4.8.0", + "chromadb": "^3.5.0", + "cloudflare": "^4.2.0", + "cohere-ai": "^7.17.0 || ^8.0.0", + "compromise": "^14.0.0", + "fastembed": "^2.1.0", + "groq-sdk": "0.3.0", + "iovalkey": "^0.3.3", + "mongodb": "^7.0.0", + "mysql2": "^3.0.0", + "natural": "^8.0.1", + "ollama": "^0.5.14", + "oracledb": "^6.5.0 || ^7.0.0", + "pg": "^8.11.3", + "redis": "^4.6.13", + "weaviate-client": "^3.0.0", + "zeroentropy": "^0.1.0-alpha.10" + }, + "peerDependenciesMeta": { + "@anthropic-ai/sdk": { + "optional": true + }, + "@aws-sdk/client-bedrock-runtime": { + "optional": true + }, + "@aws-sdk/client-neptune-graph": { + "optional": true + }, + "@aws-sdk/client-s3vectors": { + "optional": true + }, + "@azure/identity": { + "optional": true + }, + "@azure/search-documents": { + "optional": true + }, + "@databricks/sql": { + "optional": true + }, + "@elastic/elasticsearch": { + "optional": true + }, + "@google-cloud/aiplatform": { + "optional": true + }, + "@google/genai": { + "optional": true + }, + "@huggingface/transformers": { + "optional": true + }, + "@langchain/core": { + "optional": true + }, + "@mistralai/mistralai": { + "optional": true + }, + "@mochow/mochow-sdk-node": { + "optional": true + }, + "@opensearch-project/opensearch": { + "optional": true + }, + "@pinecone-database/pinecone": { + "optional": true + }, + "@qdrant/js-client-rest": { + "optional": true + }, + "@supabase/supabase-js": { + "optional": true + }, + "@turbopuffer/turbopuffer": { + "optional": true + }, + "@types/pg": { + "optional": true + }, + "@upstash/vector": { + "optional": true + }, + "@zilliz/milvus2-sdk-node": { + "optional": true + }, + "cassandra-driver": { + "optional": true + }, + "chromadb": { + "optional": true + }, + "cloudflare": { + "optional": true + }, + "cohere-ai": { + "optional": true + }, + "fastembed": { + "optional": true + }, + "groq-sdk": { + "optional": true + }, + "iovalkey": { + "optional": true + }, + "mongodb": { + "optional": true + }, + "mysql2": { + "optional": true + }, + "natural": { + "optional": true + }, + "ollama": { + "optional": true + }, + "oracledb": { + "optional": true + }, + "pg": { + "optional": true + }, + "redis": { + "optional": true + }, + "weaviate-client": { + "optional": true + }, + "zeroentropy": { + "optional": true + } + } + }, + "packages/memory-mem0/node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "license": "MIT", + "optional": true, + "peer": true + }, + "packages/memory-mem0/node_modules/uuid": { + "version": "11.1.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.1.tgz", + "integrity": "sha512-vIYxrBCC/N/K+Js3qSN88go7kIfNPssr/hHCesKCQNAjmgvYS2oqr69kIufEG+O4+PfezOH4EbIeHCfFov8ZgQ==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "bin": { + "uuid": "dist/esm/bin/uuid" + } + }, "packages/optimizer": { "name": "@waggle/optimizer", "version": "0.1.0", diff --git a/package.json b/package.json index 996685d..c372996 100644 --- a/package.json +++ b/package.json @@ -20,7 +20,7 @@ "build:dev": "cd apps/web && npx vite build --mode development --outDir ../../dist --emptyOutDir", "typecheck:web": "cd apps/web && npx tsc --noEmit -p tsconfig.app.json", "preview": "cd apps/web && npx vite preview", - "build:packages": "cd packages/shared && npx tsc --build && cd ../waggle-dance && npx tsc --build --force && cd ../hive-mind-core && npx tsc --build && cd ../core && npx tsc --build && cd ../weaver && npx tsc --build && cd ../wiki-compiler && npx tsc --build && cd ../marketplace && npx tsc --build && cd ../agent && npx tsc --build && cd ../server && npx tsc --build && cd ../worker && npm run build", + "build:packages": "cd packages/shared && npx tsc --build && cd ../memory-contract && npx tsc --build && cd ../memory-mem0 && npx tsc --build && cd ../waggle-dance && npx tsc --build --force && cd ../hive-mind-core && npx tsc --build && cd ../core && npx tsc --build && cd ../weaver && npx tsc --build && cd ../wiki-compiler && npx tsc --build && cd ../marketplace && npx tsc --build && cd ../agent && npx tsc --build && cd ../server && npx tsc --build && cd ../worker && npm run build", "build:hook-runtime": "node scripts/build-hook-runtime.mjs", "build:all": "npm run build:packages && npm run build", "dev:www": "npm run dev -w apps/www", diff --git a/packages/memory-contract/package.json b/packages/memory-contract/package.json new file mode 100644 index 0000000..f9db2f3 --- /dev/null +++ b/packages/memory-contract/package.json @@ -0,0 +1,19 @@ +{ + "name": "@waggle/memory-contract", + "version": "0.1.0", + "description": "The interface Waggle uses to reach memory, plus an in-memory implementation for development and tests", + "license": "MIT", + "type": "module", + "exports": { + ".": { + "types": "./dist/index.d.ts", + "import": "./dist/index.js" + } + }, + "main": "dist/index.js", + "types": "dist/index.d.ts", + "scripts": { + "build": "tsc", + "test": "node ../../node_modules/vitest/vitest.mjs run --root ../.. --config vitest.config.ts packages/memory-contract/tests" + } +} diff --git a/packages/memory-contract/src/helpers.ts b/packages/memory-contract/src/helpers.ts new file mode 100644 index 0000000..798a4a8 --- /dev/null +++ b/packages/memory-contract/src/helpers.ts @@ -0,0 +1,114 @@ +import { + MEMORY_IMPORTANCE, + MEMORY_KINDS, + MEMORY_SOURCES, + RESERVED_METADATA_KEYS, + type ConversationMessage, + type MemoryFilter, + type MemoryImportance, + type MemoryKind, + type MemoryScope, + type MemorySource, + type RememberInput, +} from './types.js'; + +export const PERSONAL_SCOPE: MemoryScope = { kind: 'personal' }; + +export function workspaceScope(workspaceId: string): MemoryScope { + if (!workspaceId.trim()) throw new TypeError('workspaceId must not be empty'); + return { kind: 'workspace', workspaceId }; +} + +/** Stable string form of a scope: 'personal' or 'workspace:'. */ +export function scopeKey(scope: MemoryScope): string { + return scope.kind === 'personal' ? 'personal' : `workspace:${scope.workspaceId}`; +} + +export function scopeFromKey(key: string): MemoryScope | null { + if (key === 'personal') return PERSONAL_SCOPE; + if (key.startsWith('workspace:') && key.length > 'workspace:'.length) { + return { kind: 'workspace', workspaceId: key.slice('workspace:'.length) }; + } + return null; +} + +/** Importance levels at or above `min`. */ +export function importanceAtLeast(min: MemoryImportance): MemoryImportance[] { + return MEMORY_IMPORTANCE.slice(0, MEMORY_IMPORTANCE.indexOf(min) + 1); +} + +export interface NormalizedRememberInput { + readonly scope: MemoryScope; + readonly text: string | null; + readonly conversation: readonly ConversationMessage[] | null; + readonly kind: MemoryKind; + readonly importance: MemoryImportance; + readonly source: MemorySource; + readonly origin: string | null; + readonly sessionId: string | null; + readonly metadata: Readonly>; +} + +/** Validates a `remember` call and fills in the defaults. Throws `TypeError` on bad input. */ +export function normalizeRememberInput(input: RememberInput): NormalizedRememberInput { + assertScope(input.scope); + const hasText = input.text !== undefined; + const hasConversation = input.conversation !== undefined; + if (hasText === hasConversation) { + throw new TypeError('remember needs exactly one of text and conversation'); + } + const text = hasText ? input.text!.trim() : null; + if (hasText && !text) throw new TypeError('text must not be empty'); + if (hasConversation && !input.conversation!.some((m) => m.content.trim())) { + throw new TypeError('conversation must contain at least one non-empty message'); + } + const kind = input.kind ?? 'fact'; + const importance = input.importance ?? 'normal'; + const source = input.source ?? 'agent_inferred'; + assertOneOf('kind', kind, MEMORY_KINDS); + assertOneOf('importance', importance, MEMORY_IMPORTANCE); + assertOneOf('source', source, MEMORY_SOURCES); + const metadata = input.metadata ?? {}; + assertNoReservedKeys(metadata); + return { + scope: input.scope, + text, + conversation: hasConversation ? input.conversation! : null, + kind, + importance, + source, + origin: input.origin ?? null, + sessionId: input.sessionId ?? null, + metadata, + }; +} + +export function assertFilter(filter: MemoryFilter): void { + if (filter.scopes.length === 0) throw new TypeError('filter needs at least one scope'); + for (const scope of filter.scopes) assertScope(scope); + for (const kind of filter.kinds ?? []) assertOneOf('kind', kind, MEMORY_KINDS); + if (filter.minImportance !== undefined) { + assertOneOf('minImportance', filter.minImportance, MEMORY_IMPORTANCE); + } +} + +export function assertNoReservedKeys(metadata: Readonly>): void { + for (const key of RESERVED_METADATA_KEYS) { + if (key in metadata) throw new TypeError(`metadata key "${key}" is reserved`); + } +} + +function assertScope(scope: MemoryScope): void { + if (scope.kind === 'workspace' && !scope.workspaceId?.trim()) { + throw new TypeError('workspace scope needs a workspaceId'); + } + if (scope.kind !== 'personal' && scope.kind !== 'workspace') { + throw new TypeError(`unknown scope kind: ${String((scope as { kind: unknown }).kind)}`); + } +} + +function assertOneOf(name: string, value: string, allowed: readonly T[]): void { + if (!allowed.includes(value as T)) { + throw new TypeError(`${name} must be one of ${allowed.join(', ')} (got "${value}")`); + } +} diff --git a/packages/memory-contract/src/in-memory-store.ts b/packages/memory-contract/src/in-memory-store.ts new file mode 100644 index 0000000..a7600eb --- /dev/null +++ b/packages/memory-contract/src/in-memory-store.ts @@ -0,0 +1,179 @@ +import { randomUUID } from 'node:crypto'; +import { + assertFilter, + assertNoReservedKeys, + importanceAtLeast, + normalizeRememberInput, + scopeKey, +} from './helpers.js'; +import { + MemoryCapabilityError, + MemoryNotFoundError, + type MemoryCapabilities, + type MemoryChange, + type MemoryFilter, + type MemoryHistoryEntry, + type MemoryHit, + type MemoryQuery, + type MemoryRecord, + type MemoryStore, + type MemoryUpdate, + type RememberInput, +} from './types.js'; + +const CAPABILITIES: MemoryCapabilities = { + extraction: false, + semanticSearch: false, + history: true, + knowledgeGraph: false, +}; + +/** + * A `MemoryStore` that keeps everything in process memory. Search ranks by + * shared words. Meant for development and tests; nothing survives a restart. + */ +export function createInMemoryMemoryStore(): MemoryStore { + const records = new Map(); + const histories = new Map(); + let closed = false; + + const ensureOpen = (): void => { + if (closed) throw new Error('memory store is closed'); + }; + + const log = (id: string, entry: MemoryHistoryEntry): void => { + histories.set(id, [...(histories.get(id) ?? []), entry]); + }; + + const matching = (filter: MemoryFilter): MemoryRecord[] => { + assertFilter(filter); + const scopes = new Set(filter.scopes.map(scopeKey)); + const importance = filter.minImportance ? new Set(importanceAtLeast(filter.minImportance)) : null; + return [...records.values()].filter((r) => + scopes.has(scopeKey(r.scope)) + && (!filter.kinds || filter.kinds.includes(r.kind)) + && (!importance || importance.has(r.importance)) + && (filter.origin === undefined || r.origin === filter.origin) + && (filter.sessionId === undefined || r.sessionId === filter.sessionId) + && (filter.since === undefined || r.createdAt >= filter.since) + && (filter.until === undefined || r.createdAt <= filter.until)); + }; + + const newestFirst = (a: MemoryRecord, b: MemoryRecord): number => + b.createdAt.localeCompare(a.createdAt); + + const forget = (id: string): boolean => { + const current = records.get(id); + if (!current) return false; + records.delete(id); + log(id, { event: 'deleted', previousText: current.text, text: null, at: new Date().toISOString() }); + return true; + }; + + return { + capabilities: CAPABILITIES, + + async remember(input: RememberInput): Promise { + ensureOpen(); + const normalized = normalizeRememberInput(input); + if (normalized.conversation) throw new MemoryCapabilityError('extraction'); + const text = normalized.text!; + const existing = [...records.values()].find((r) => + r.text === text && scopeKey(r.scope) === scopeKey(normalized.scope)); + if (existing) return [{ event: 'unchanged', record: existing }]; + const record: MemoryRecord = { + id: randomUUID(), + text, + scope: normalized.scope, + kind: normalized.kind, + importance: normalized.importance, + source: normalized.source, + origin: normalized.origin, + sessionId: normalized.sessionId, + createdAt: new Date().toISOString(), + updatedAt: null, + metadata: { ...normalized.metadata }, + }; + records.set(record.id, record); + log(record.id, { event: 'added', previousText: null, text, at: record.createdAt }); + return [{ event: 'added', record }]; + }, + + async search(text: string, query: MemoryQuery): Promise { + ensureOpen(); + const queryWords = words(text); + return matching(query) + .map((r) => ({ ...r, score: overlap(queryWords, words(r.text)) })) + .filter((hit) => hit.score > 0) + .sort((a, b) => b.score - a.score || newestFirst(a, b)) + .slice(0, query.limit ?? 10); + }, + + async list(query: MemoryQuery): Promise { + ensureOpen(); + return matching(query).sort(newestFirst).slice(0, query.limit ?? 50); + }, + + async count(filter: MemoryFilter): Promise { + ensureOpen(); + return matching(filter).length; + }, + + async get(id: string): Promise { + ensureOpen(); + return records.get(id) ?? null; + }, + + async update(id: string, change: MemoryUpdate): Promise { + ensureOpen(); + const current = records.get(id); + if (!current) throw new MemoryNotFoundError(id); + if (change.metadata) assertNoReservedKeys(change.metadata); + const text = change.text?.trim() || current.text; + const updated: MemoryRecord = { + ...current, + text, + kind: change.kind ?? current.kind, + importance: change.importance ?? current.importance, + metadata: { ...current.metadata, ...change.metadata }, + updatedAt: new Date().toISOString(), + }; + records.set(id, updated); + log(id, { event: 'updated', previousText: current.text, text, at: updated.updatedAt! }); + return updated; + }, + + async forget(id: string): Promise { + ensureOpen(); + return forget(id); + }, + + async forgetMatching(filter: MemoryFilter): Promise { + ensureOpen(); + const doomed = matching(filter); + for (const record of doomed) forget(record.id); + return doomed.length; + }, + + async history(id: string): Promise { + ensureOpen(); + return histories.get(id) ?? []; + }, + + async close(): Promise { + closed = true; + }, + }; +} + +function words(text: string): Set { + return new Set(text.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? []); +} + +/** Cosine similarity of two word sets. */ +function overlap(a: Set, b: Set): number { + if (a.size === 0 || b.size === 0) return 0; + let shared = 0; + for (const word of a) if (b.has(word)) shared += 1; + return shared / Math.sqrt(a.size * b.size); +} diff --git a/packages/memory-contract/src/index.ts b/packages/memory-contract/src/index.ts new file mode 100644 index 0000000..7c3840a --- /dev/null +++ b/packages/memory-contract/src/index.ts @@ -0,0 +1,4 @@ +// @waggle/memory-contract +export * from './types.js'; +export * from './helpers.js'; +export { createInMemoryMemoryStore } from './in-memory-store.js'; diff --git a/packages/memory-contract/src/types.ts b/packages/memory-contract/src/types.ts new file mode 100644 index 0000000..8f0e627 --- /dev/null +++ b/packages/memory-contract/src/types.ts @@ -0,0 +1,182 @@ +/** + * The memory contract: everything Waggle may ask of memory (ADR-0002, ADR-0007). + * + * Code outside a memory implementation talks to memory only through + * `MemoryStore` and never queries a memory database directly. + */ + +/** Where a memory lives. Personal memory follows the user across workspaces. */ +export type MemoryScope = + | { readonly kind: 'personal' } + | { readonly kind: 'workspace'; readonly workspaceId: string }; + +/** What a memory is about. Replaces the content prefixes of the old frame store. */ +export const MEMORY_KINDS = [ + 'fact', + 'event', + 'preference', + 'profile', + 'decision', + 'summary', + 'note', +] as const; +export type MemoryKind = (typeof MEMORY_KINDS)[number]; + +/** Ordered from most to least important. */ +export const MEMORY_IMPORTANCE = ['critical', 'important', 'normal', 'temporary'] as const; +export type MemoryImportance = (typeof MEMORY_IMPORTANCE)[number]; + +export const MEMORY_SOURCES = [ + 'user_stated', + 'tool_verified', + 'agent_inferred', + 'import', + 'system', +] as const; +export type MemorySource = (typeof MEMORY_SOURCES)[number]; + +export interface MemoryRecord { + /** Unique across all scopes. */ + readonly id: string; + readonly text: string; + readonly scope: MemoryScope; + readonly kind: MemoryKind; + readonly importance: MemoryImportance; + readonly source: MemorySource; + /** Producer of the memory, e.g. 'chat', 'agent-run', 'loop'. */ + readonly origin: string | null; + /** Chat session the memory came from, when there is one. */ + readonly sessionId: string | null; + /** ISO 8601. */ + readonly createdAt: string; + /** ISO 8601, or null if the memory was never changed. */ + readonly updatedAt: string | null; + /** Caller-defined fields (title, tags, status…). Never repeats the fields above. */ + readonly metadata: Readonly>; +} + +export interface MemoryHit extends MemoryRecord { + /** Relevance to the query; higher is better. Comparable within one result list only. */ + readonly score: number; +} + +export interface ConversationMessage { + readonly role: 'user' | 'assistant'; + readonly content: string; +} + +export interface RememberInput { + readonly scope: MemoryScope; + /** Store this text as one memory. Exactly one of `text` and `conversation` is required. */ + readonly text?: string; + /** + * Let the store extract facts from these turns with a model. + * Requires `capabilities.extraction`. + */ + readonly conversation?: readonly ConversationMessage[]; + /** Default 'fact'. */ + readonly kind?: MemoryKind; + /** Default 'normal'. */ + readonly importance?: MemoryImportance; + /** Default 'agent_inferred'. */ + readonly source?: MemorySource; + readonly origin?: string; + readonly sessionId?: string; + /** Must not use the reserved keys in `RESERVED_METADATA_KEYS`. */ + readonly metadata?: Readonly>; +} + +export interface MemoryChange { + /** 'unchanged' means the same text already existed in the scope; nothing was written. */ + readonly event: 'added' | 'unchanged'; + readonly record: MemoryRecord; +} + +export interface MemoryFilter { + /** Scopes to read from; results of all of them are merged. At least one. */ + readonly scopes: readonly MemoryScope[]; + readonly kinds?: readonly MemoryKind[]; + /** Lowest importance to include: 'important' returns critical and important. */ + readonly minImportance?: MemoryImportance; + readonly origin?: string; + readonly sessionId?: string; + /** Inclusive ISO 8601 bounds on `createdAt`. */ + readonly since?: string; + readonly until?: string; +} + +export interface MemoryQuery extends MemoryFilter { + readonly limit?: number; +} + +export interface MemoryUpdate { + readonly text?: string; + readonly kind?: MemoryKind; + readonly importance?: MemoryImportance; + /** Merged into the existing metadata. */ + readonly metadata?: Readonly>; +} + +export interface MemoryHistoryEntry { + readonly event: 'added' | 'updated' | 'deleted'; + readonly previousText: string | null; + readonly text: string | null; + /** ISO 8601. */ + readonly at: string; +} + +export interface MemoryCapabilities { + /** `remember({ conversation })` extracts facts with a model. */ + readonly extraction: boolean; + /** `search` ranks by meaning, not only by shared words. */ + readonly semanticSearch: boolean; + /** `history` returns the change log. */ + readonly history: boolean; + /** Entities and relations between memories. Not part of v1 (ADR-0002). */ + readonly knowledgeGraph: boolean; +} + +export interface MemoryStore { + readonly capabilities: MemoryCapabilities; + /** Write memory. Identical text in the same scope is not written twice. */ + remember(input: RememberInput): Promise; + /** Most relevant first. Default limit 10. */ + search(text: string, query: MemoryQuery): Promise; + /** Newest first. Default limit 50. */ + list(query: MemoryQuery): Promise; + count(filter: MemoryFilter): Promise; + get(id: string): Promise; + /** Throws `MemoryNotFoundError` when the id is unknown. */ + update(id: string, change: MemoryUpdate): Promise; + /** Returns false when the id is unknown. */ + forget(id: string): Promise; + /** Deletes every memory matching the filter and returns how many. */ + forgetMatching(filter: MemoryFilter): Promise; + /** Oldest first. Empty when `capabilities.history` is false. */ + history(id: string): Promise; + /** Releases resources. The store must not be used afterwards. */ + close(): Promise; +} + +/** Metadata keys a caller may not set: they hold the record's own fields. */ +export const RESERVED_METADATA_KEYS = [ + 'kind', + 'importance', + 'source', + 'origin', + 'session_id', +] as const; + +export class MemoryNotFoundError extends Error { + constructor(readonly memoryId: string) { + super(`Memory not found: ${memoryId}`); + this.name = 'MemoryNotFoundError'; + } +} + +export class MemoryCapabilityError extends Error { + constructor(readonly capability: keyof MemoryCapabilities) { + super(`This memory store does not support ${capability}`); + this.name = 'MemoryCapabilityError'; + } +} diff --git a/packages/memory-contract/tests/contract-suite.ts b/packages/memory-contract/tests/contract-suite.ts new file mode 100644 index 0000000..0da3ce7 --- /dev/null +++ b/packages/memory-contract/tests/contract-suite.ts @@ -0,0 +1,206 @@ +/** + * Behaviour every `MemoryStore` implementation must show. Each implementation's + * test file calls `describeMemoryStoreContract` with a factory for a fresh store. + */ +import { afterEach, beforeEach, describe, expect, it } from 'vitest'; +import { + MemoryCapabilityError, + MemoryNotFoundError, + PERSONAL_SCOPE, + workspaceScope, + type MemoryStore, +} from '../src/index.js'; + +const ALPHA = workspaceScope('alpha'); +const BETA = workspaceScope('beta'); + +const tick = (): Promise => new Promise((resolve) => setTimeout(resolve, 15)); + +export function describeMemoryStoreContract(name: string, open: () => Promise): void { + describe(`${name} — memory contract`, () => { + let store: MemoryStore; + + beforeEach(async () => { + store = await open(); + }); + + afterEach(async () => { + await store.close(); + }); + + async function add(text: string, extra: Record = {}) { + const [change] = await store.remember({ scope: ALPHA, text, ...extra }); + return change.record; + } + + it('remembers text with defaults and reads it back by id', async () => { + const [change] = await store.remember({ scope: ALPHA, text: ' The launch is on Friday ' }); + expect(change.event).toBe('added'); + const stored = await store.get(change.record.id); + expect(stored).toMatchObject({ + id: change.record.id, + text: 'The launch is on Friday', + scope: ALPHA, + kind: 'fact', + importance: 'normal', + source: 'agent_inferred', + origin: null, + sessionId: null, + updatedAt: null, + metadata: {}, + }); + expect(Number.isNaN(Date.parse(stored!.createdAt))).toBe(false); + expect(await store.get('no-such-id')).toBeNull(); + }); + + it('keeps the record fields and caller metadata', async () => { + const record = await add('Use the blue logo on slides', { + kind: 'decision', + importance: 'important', + source: 'user_stated', + origin: 'chat', + sessionId: 'session-1', + metadata: { title: 'Logo', tags: ['brand'] }, + }); + expect(await store.get(record.id)).toMatchObject({ + kind: 'decision', + importance: 'important', + source: 'user_stated', + origin: 'chat', + sessionId: 'session-1', + metadata: { title: 'Logo', tags: ['brand'] }, + }); + }); + + it('does not write identical text twice in one scope', async () => { + const first = await add('The office is in Belgrade'); + const [again] = await store.remember({ scope: ALPHA, text: 'The office is in Belgrade' }); + expect(again.event).toBe('unchanged'); + expect(again.record.id).toBe(first.id); + const [elsewhere] = await store.remember({ scope: BETA, text: 'The office is in Belgrade' }); + expect(elsewhere.event).toBe('added'); + expect(await store.count({ scopes: [ALPHA, BETA] })).toBe(2); + }); + + it('keeps scopes apart in list, count and search', async () => { + await add('Alpha uses PostgreSQL'); + await store.remember({ scope: BETA, text: 'Beta uses PostgreSQL too' }); + await store.remember({ scope: PERSONAL_SCOPE, text: 'I like PostgreSQL' }); + expect((await store.list({ scopes: [ALPHA] })).map((r) => r.text)).toEqual(['Alpha uses PostgreSQL']); + expect(await store.count({ scopes: [BETA] })).toBe(1); + expect(await store.count({ scopes: [ALPHA, PERSONAL_SCOPE] })).toBe(2); + const hits = await store.search('PostgreSQL', { scopes: [PERSONAL_SCOPE] }); + expect(hits.map((h) => h.text)).toEqual(['I like PostgreSQL']); + }); + + it('ranks a memory first when the query repeats its words', async () => { + await add('The team offsite is in Lisbon in May'); + await add('The user prefers tea over coffee'); + await add('The budget for the Paris trip is 2000 euros'); + const hits = await store.search('budget Paris trip euros', { scopes: [ALPHA], limit: 2 }); + expect(hits.length).toBeGreaterThan(0); + expect(hits.length).toBeLessThanOrEqual(2); + expect(hits[0].text).toBe('The budget for the Paris trip is 2000 euros'); + expect(typeof hits[0].score).toBe('number'); + }); + + it('filters by kind, importance, origin and session', async () => { + await add('Ship the beta', { kind: 'decision', importance: 'critical', origin: 'chat', sessionId: 's1' }); + await add('Weekly sync moved to Tuesday', { kind: 'event', importance: 'normal', origin: 'loop' }); + await add('Prefers short answers', { kind: 'preference', importance: 'important', origin: 'chat', sessionId: 's2' }); + const texts = async (filter: Record) => + (await store.list({ scopes: [ALPHA], ...filter })).map((r) => r.text).sort(); + expect(await texts({ kinds: ['decision', 'event'] })).toEqual(['Ship the beta', 'Weekly sync moved to Tuesday']); + expect(await texts({ minImportance: 'important' })).toEqual(['Prefers short answers', 'Ship the beta']); + expect(await texts({ origin: 'loop' })).toEqual(['Weekly sync moved to Tuesday']); + expect(await texts({ sessionId: 's2' })).toEqual(['Prefers short answers']); + const hits = await store.search('beta', { scopes: [ALPHA], kinds: ['event'] }); + expect(hits.every((h) => h.kind === 'event')).toBe(true); + }); + + it('filters by creation time', async () => { + const early = await add('Early note'); + await tick(); + const late = await add('Late note'); + expect((await store.list({ scopes: [ALPHA], since: late.createdAt })).map((r) => r.text)).toEqual(['Late note']); + expect((await store.list({ scopes: [ALPHA], until: early.createdAt })).map((r) => r.text)).toEqual(['Early note']); + }); + + it('lists newest first and honours the limit', async () => { + await add('First'); + await tick(); + await add('Second'); + await tick(); + await add('Third'); + expect((await store.list({ scopes: [ALPHA] })).map((r) => r.text)).toEqual(['Third', 'Second', 'First']); + expect((await store.list({ scopes: [ALPHA], limit: 2 })).map((r) => r.text)).toEqual(['Third', 'Second']); + }); + + it('updates text and importance and merges metadata', async () => { + const record = await add('Draft due Monday', { metadata: { status: 'open', owner: 'nik' } }); + const updated = await store.update(record.id, { + text: 'Draft due Tuesday', + importance: 'important', + metadata: { status: 'done' }, + }); + expect(updated).toMatchObject({ + id: record.id, + text: 'Draft due Tuesday', + importance: 'important', + metadata: { status: 'done', owner: 'nik' }, + }); + expect(updated.updatedAt).not.toBeNull(); + expect(await store.get(record.id)).toMatchObject({ text: 'Draft due Tuesday', importance: 'important' }); + await expect(store.update('no-such-id', { text: 'x' })).rejects.toBeInstanceOf(MemoryNotFoundError); + }); + + it('forgets one memory and reports unknown ids', async () => { + const record = await add('Temporary note'); + expect(await store.forget(record.id)).toBe(true); + expect(await store.get(record.id)).toBeNull(); + expect(await store.forget(record.id)).toBe(false); + }); + + it('forgets everything matching a filter', async () => { + await add('Loop result one', { origin: 'loop' }); + await add('Loop result two', { origin: 'loop' }); + await add('Chat fact', { origin: 'chat' }); + await store.remember({ scope: BETA, text: 'Loop result in beta', origin: 'loop' }); + expect(await store.forgetMatching({ scopes: [ALPHA], origin: 'loop' })).toBe(2); + expect((await store.list({ scopes: [ALPHA] })).map((r) => r.text)).toEqual(['Chat fact']); + expect(await store.count({ scopes: [BETA] })).toBe(1); + }); + + it('keeps a change history when it supports one', async () => { + const record = await add('Version one'); + await store.update(record.id, { text: 'Version two' }); + const history = await store.history(record.id); + if (!store.capabilities.history) { + expect(history).toEqual([]); + return; + } + expect(history.map((h) => h.event)).toEqual(['added', 'updated']); + expect(history[1]).toMatchObject({ previousText: 'Version one', text: 'Version two' }); + }); + + it('rejects malformed input', async () => { + await expect(store.remember({ scope: ALPHA })).rejects.toThrow(TypeError); + await expect(store.remember({ scope: ALPHA, text: ' ' })).rejects.toThrow(TypeError); + await expect(store.remember({ scope: ALPHA, text: 'x', metadata: { kind: 'event' } })).rejects.toThrow(TypeError); + await expect(store.list({ scopes: [] })).rejects.toThrow(TypeError); + await expect(store.remember({ scope: { kind: 'workspace', workspaceId: '' }, text: 'x' })).rejects.toThrow(TypeError); + }); + + it('refuses conversations when it cannot extract facts', async () => { + if (store.capabilities.extraction) return; + await expect(store.remember({ + scope: ALPHA, + conversation: [{ role: 'user', content: 'My name is Ana' }], + })).rejects.toBeInstanceOf(MemoryCapabilityError); + }); + + it('does not claim a knowledge graph', () => { + expect(store.capabilities.knowledgeGraph).toBe(false); + }); + }); +} diff --git a/packages/memory-contract/tests/in-memory-store.test.ts b/packages/memory-contract/tests/in-memory-store.test.ts new file mode 100644 index 0000000..8d77054 --- /dev/null +++ b/packages/memory-contract/tests/in-memory-store.test.ts @@ -0,0 +1,4 @@ +import { createInMemoryMemoryStore } from '../src/index.js'; +import { describeMemoryStoreContract } from './contract-suite.js'; + +describeMemoryStoreContract('in-memory store', async () => createInMemoryMemoryStore()); diff --git a/packages/memory-contract/tsconfig.json b/packages/memory-contract/tsconfig.json new file mode 100644 index 0000000..b0c54fe --- /dev/null +++ b/packages/memory-contract/tsconfig.json @@ -0,0 +1,21 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "moduleResolution": "bundler", + "lib": ["ES2022"], + "outDir": "dist", + "rootDir": "src", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "declaration": true, + "declarationMap": true, + "sourceMap": true, + "composite": true + }, + "include": ["src/**/*.ts"], + "exclude": ["node_modules", "dist", "tests"] +} diff --git a/packages/memory-mem0/package.json b/packages/memory-mem0/package.json new file mode 100644 index 0000000..2acc249 --- /dev/null +++ b/packages/memory-mem0/package.json @@ -0,0 +1,23 @@ +{ + "name": "@waggle/memory-mem0", + "version": "0.1.0", + "description": "Memory store for Waggle backed by the open-source mem0 library, run locally", + "license": "MIT", + "type": "module", + "exports": { + ".": { + "types": "./dist/index.d.ts", + "import": "./dist/index.js" + } + }, + "main": "dist/index.js", + "types": "dist/index.d.ts", + "scripts": { + "build": "tsc", + "test": "node ../../node_modules/vitest/vitest.mjs run --root ../.. --config vitest.config.ts packages/memory-mem0/tests" + }, + "dependencies": { + "@waggle/memory-contract": "*", + "mem0ai": "3.3.1" + } +} diff --git a/packages/memory-mem0/src/index.ts b/packages/memory-mem0/src/index.ts new file mode 100644 index 0000000..96febb3 --- /dev/null +++ b/packages/memory-mem0/src/index.ts @@ -0,0 +1,345 @@ +/** + * A `MemoryStore` backed by the open-source mem0 library, run in-process + * (ADR-0002, ADR-0007). Everything lives in SQLite files in one directory. + * + * Mapping onto mem0: every memory belongs to user 'local'; the memory scope is + * mem0's `agent_id` ('personal' or 'workspace:'), so mem0 never compares + * facts across scopes. The contract's own fields are kept in mem0 metadata. + */ +import { createHash } from 'node:crypto'; +import { mkdirSync } from 'node:fs'; +import path from 'node:path'; +import type { Memory, MemoryItem } from 'mem0ai/oss'; +import { + MEMORY_IMPORTANCE, + MEMORY_KINDS, + MEMORY_SOURCES, + MemoryCapabilityError, + MemoryNotFoundError, + RESERVED_METADATA_KEYS, + assertFilter, + assertNoReservedKeys, + importanceAtLeast, + normalizeRememberInput, + scopeFromKey, + scopeKey, + type MemoryCapabilities, + type MemoryChange, + type MemoryFilter, + type MemoryHistoryEntry, + type MemoryHit, + type MemoryImportance, + type MemoryKind, + type MemoryQuery, + type MemoryRecord, + type MemoryScope, + type MemorySource, + type MemoryStore, + type MemoryUpdate, + type RememberInput, +} from '@waggle/memory-contract'; + +/** Turns text into vectors. Waggle passes its in-process embedder. */ +export interface TextEmbedder { + readonly dimensions: number; + embed(text: string): Promise>; + embedBatch(texts: string[]): Promise[]>; +} + +/** An OpenAI-compatible chat endpoint, used to extract facts from conversations. */ +export interface ExtractionModel { + readonly baseURL: string; + readonly apiKey: string; + readonly model: string; +} + +export interface Mem0MemoryStoreOptions { + /** Directory for the SQLite files; created when missing. */ + readonly directory: string; + readonly embedder: TextEmbedder; + /** Without it the store cannot extract facts (`capabilities.extraction` is false). */ + readonly extractionModel?: ExtractionModel; +} + +const USER_ID = 'local'; +/** mem0 has no unbounded listing; this is far above a personal memory's size. */ +const ALL = 1_000_000; +/** Candidates fetched per scope before the contract's filters are applied. */ +const SEARCH_POOL = 100; + +export async function createMem0MemoryStore(options: Mem0MemoryStoreOptions): Promise { + mkdirSync(options.directory, { recursive: true }); + // mem0 reads both variables once, when its module loads. Its telemetry would + // send every call to mem0's PostHog project (ADR-0006), and MEM0_DIR keeps it + // out of ~/.mem0. That is why mem0 is imported here and not at the top. + process.env.MEM0_TELEMETRY = 'false'; + process.env.MEM0_DIR = options.directory; + const { Memory: Mem0 } = await import('mem0ai/oss'); + + const model = options.extractionModel; + const mem0: Memory = new Mem0({ + version: 'v1.1', + embedder: { provider: 'langchain', config: { model: asLangchainEmbeddings(options.embedder) } }, + vectorStore: { + provider: 'memory', + config: { + collectionName: 'waggle', + dimension: options.embedder.dimensions, + dbPath: path.join(options.directory, 'vectors.db'), + }, + }, + // mem0 requires an LLM even when nothing calls it; without a model it is never used. + llm: { + provider: 'openai', + config: model + ? { baseURL: model.baseURL, apiKey: model.apiKey, model: model.model } + : { baseURL: 'http://127.0.0.1:9/v1', apiKey: 'unused', model: 'unused' }, + }, + historyStore: { + provider: 'sqlite', + config: { historyDbPath: path.join(options.directory, 'history.db') }, + }, + }); + + const capabilities: MemoryCapabilities = { + extraction: model !== undefined, + semanticSearch: true, + history: true, + knowledgeGraph: false, + }; + + let closed = false; + const ensureOpen = (): void => { + if (closed) throw new Error('memory store is closed'); + }; + + const scopeItems = async (scope: MemoryScope): Promise => { + const { results } = await mem0.getAll({ topK: ALL, filters: scopeFilter(scope) }); + return results; + }; + + const matching = async (filter: MemoryFilter): Promise => { + assertFilter(filter); + const records: MemoryRecord[] = []; + for (const scope of filter.scopes) { + for (const item of await scopeItems(scope)) { + const record = toRecord(item); + if (record && passes(record, filter)) records.push(record); + } + } + return records; + }; + + const getRecord = async (id: string): Promise => { + const item = await mem0.get(id); + return item ? toRecord(item) : null; + }; + + return { + capabilities, + + async remember(input: RememberInput): Promise { + ensureOpen(); + const normalized = normalizeRememberInput(input); + const metadata = { + ...normalized.metadata, + kind: normalized.kind, + importance: normalized.importance, + source: normalized.source, + ...(normalized.origin !== null && { origin: normalized.origin }), + ...(normalized.sessionId !== null && { session_id: normalized.sessionId }), + }; + const target = { userId: USER_ID, agentId: scopeKey(normalized.scope), metadata }; + + if (normalized.conversation) { + if (!model) throw new MemoryCapabilityError('extraction'); + const messages = normalized.conversation + .filter((m) => m.content.trim()) + .map((m) => ({ role: m.role, content: m.content })); + const { results } = await mem0.add(messages, { ...target, infer: true }); + return toChanges(results, getRecord, 'added'); + } + + const text = normalized.text!; + const { results: existing } = await mem0.getAll({ + topK: 1, + filters: { ...scopeFilter(normalized.scope), hash: md5(text) }, + }); + const duplicate = existing[0] ? toRecord(existing[0]) : null; + if (duplicate) return [{ event: 'unchanged', record: duplicate }]; + const { results } = await mem0.add(text, { ...target, infer: false }); + return toChanges(results, getRecord, 'added'); + }, + + async search(text: string, query: MemoryQuery): Promise { + ensureOpen(); + assertFilter(query); + const limit = query.limit ?? 10; + const hits: MemoryHit[] = []; + for (const scope of query.scopes) { + const { results } = await mem0.search(text, { + topK: Math.max(limit * 5, SEARCH_POOL), + threshold: 0, + filters: scopeFilter(scope), + }); + for (const item of results) { + const record = toRecord(item); + if (record && passes(record, query)) hits.push({ ...record, score: item.score ?? 0 }); + } + } + return hits.sort((a, b) => b.score - a.score).slice(0, limit); + }, + + async list(query: MemoryQuery): Promise { + ensureOpen(); + const records = await matching(query); + return records + .sort((a, b) => b.createdAt.localeCompare(a.createdAt)) + .slice(0, query.limit ?? 50); + }, + + async count(filter: MemoryFilter): Promise { + ensureOpen(); + return (await matching(filter)).length; + }, + + async get(id: string): Promise { + ensureOpen(); + return getRecord(id); + }, + + async update(id: string, change: MemoryUpdate): Promise { + ensureOpen(); + if (!(await getRecord(id))) throw new MemoryNotFoundError(id); + if (change.metadata) assertNoReservedKeys(change.metadata); + await mem0.update(id, { + ...(change.text?.trim() && { text: change.text.trim() }), + metadata: { + ...change.metadata, + ...(change.kind && { kind: change.kind }), + ...(change.importance && { importance: change.importance }), + }, + }); + const updated = await getRecord(id); + if (!updated) throw new MemoryNotFoundError(id); + return updated; + }, + + async forget(id: string): Promise { + ensureOpen(); + if (!(await getRecord(id))) return false; + await mem0.delete(id); + return true; + }, + + async forgetMatching(filter: MemoryFilter): Promise { + ensureOpen(); + const doomed = await matching(filter); + for (const record of doomed) await mem0.delete(record.id); + return doomed.length; + }, + + async history(id: string): Promise { + ensureOpen(); + const rows = (await mem0.history(id)) as HistoryRow[]; + return rows + .map(toHistoryEntry) + .filter((entry): entry is MemoryHistoryEntry => entry !== null) + .sort((a, b) => a.at.localeCompare(b.at)); + }, + + async close(): Promise { + // mem0 keeps its SQLite handles open for the life of the process. + closed = true; + }, + }; +} + +interface HistoryRow { + action?: string; + previous_value?: string | null; + new_value?: string | null; + created_at?: string | null; + updated_at?: string | null; +} + +const HISTORY_EVENTS: Record = { + ADD: 'added', + UPDATE: 'updated', + DELETE: 'deleted', +}; + +function toHistoryEntry(row: HistoryRow): MemoryHistoryEntry | null { + const event = HISTORY_EVENTS[row.action ?? '']; + const at = row.updated_at ?? row.created_at; + if (!event || !at) return null; + return { event, previousText: row.previous_value ?? null, text: row.new_value ?? null, at }; +} + +function scopeFilter(scope: MemoryScope): { user_id: string; agent_id: string } { + return { user_id: USER_ID, agent_id: scopeKey(scope) }; +} + +/** mem0 hashes memory text with md5; the same hash finds an identical memory. */ +function md5(text: string): string { + return createHash('md5').update(text).digest('hex'); +} + +function passes(record: MemoryRecord, filter: MemoryFilter): boolean { + const importance = filter.minImportance ? importanceAtLeast(filter.minImportance) : null; + return (!filter.kinds || filter.kinds.includes(record.kind)) + && (!importance || importance.includes(record.importance)) + && (filter.origin === undefined || record.origin === filter.origin) + && (filter.sessionId === undefined || record.sessionId === filter.sessionId) + && (filter.since === undefined || record.createdAt >= filter.since) + && (filter.until === undefined || record.createdAt <= filter.until); +} + +/** Converts a mem0 item, or returns null for an item this store did not write. */ +function toRecord(item: MemoryItem & { user_id?: string; agent_id?: string }): MemoryRecord | null { + const scope = item.agent_id ? scopeFromKey(item.agent_id) : null; + if (!scope || item.user_id !== USER_ID || !item.createdAt) return null; + const metadata: Record = { ...item.metadata }; + const own = Object.fromEntries(RESERVED_METADATA_KEYS.map((key) => [key, metadata[key]])); + for (const key of RESERVED_METADATA_KEYS) delete metadata[key]; + const updatedAt = item.updatedAt && item.updatedAt !== item.createdAt ? item.updatedAt : null; + return { + id: item.id, + text: item.memory, + scope, + kind: oneOf(own.kind, MEMORY_KINDS, 'fact') as MemoryKind, + importance: oneOf(own.importance, MEMORY_IMPORTANCE, 'normal') as MemoryImportance, + source: oneOf(own.source, MEMORY_SOURCES, 'agent_inferred') as MemorySource, + origin: typeof own.origin === 'string' ? own.origin : null, + sessionId: typeof own.session_id === 'string' ? own.session_id : null, + createdAt: item.createdAt, + updatedAt, + metadata, + }; +} + +function oneOf(value: unknown, allowed: readonly string[], fallback: string): string { + return typeof value === 'string' && allowed.includes(value) ? value : fallback; +} + +async function toChanges( + results: ReadonlyArray<{ id: string }>, + getRecord: (id: string) => Promise, + event: MemoryChange['event'], +): Promise { + const changes: MemoryChange[] = []; + for (const { id } of results) { + const record = await getRecord(id); + if (record) changes.push({ event, record }); + } + return changes; +} + +/** mem0's `langchain` embedder provider accepts any object with these two methods. */ +function asLangchainEmbeddings(embedder: TextEmbedder) { + return { + embedQuery: async (text: string): Promise => Array.from(await embedder.embed(text)), + embedDocuments: async (texts: string[]): Promise => + (await embedder.embedBatch(texts)).map((vector) => Array.from(vector)), + }; +} diff --git a/packages/memory-mem0/tests/mem0-store.test.ts b/packages/memory-mem0/tests/mem0-store.test.ts new file mode 100644 index 0000000..358cb04 --- /dev/null +++ b/packages/memory-mem0/tests/mem0-store.test.ts @@ -0,0 +1,128 @@ +import fs from 'node:fs'; +import http from 'node:http'; +import type { AddressInfo } from 'node:net'; +import os from 'node:os'; +import path from 'node:path'; +import { afterEach, describe, expect, it, vi } from 'vitest'; +import { PERSONAL_SCOPE } from '@waggle/memory-contract'; +import { createMem0MemoryStore, type TextEmbedder } from '../src/index.js'; +import { describeMemoryStoreContract } from '../../memory-contract/tests/contract-suite.js'; + +/** Deterministic bag-of-words embedder: texts that share words get similar vectors. */ +const wordEmbedder: TextEmbedder = { + dimensions: 256, + async embed(text) { + const vector = new Array(256).fill(0); + for (const word of text.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? []) { + let hash = 2166136261; + for (const char of word) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619); + vector[Math.abs(hash) % 256] += 1; + } + const norm = Math.hypot(...vector) || 1; + return vector.map((value) => value / norm); + }, + async embedBatch(texts) { + return Promise.all(texts.map((text) => this.embed(text))); + }, +}; + +const tempDirs: string[] = []; +function tempDir(): string { + const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'waggle-mem0-')); + tempDirs.push(dir); + return dir; +} + +afterEach(() => { + vi.restoreAllMocks(); +}); + +describeMemoryStoreContract('mem0 store', () => + createMem0MemoryStore({ directory: tempDir(), embedder: wordEmbedder })); + +describe('mem0 store — local behaviour', () => { + it('keeps memories across a restart', async () => { + const directory = tempDir(); + const first = await createMem0MemoryStore({ directory, embedder: wordEmbedder }); + const [change] = await first.remember({ scope: PERSONAL_SCOPE, text: 'My sister lives in Zagreb' }); + await first.close(); + + const second = await createMem0MemoryStore({ directory, embedder: wordEmbedder }); + expect(await second.get(change.record.id)).toMatchObject({ text: 'My sister lives in Zagreb' }); + expect(await second.count({ scopes: [PERSONAL_SCOPE] })).toBe(1); + await second.close(); + expect(fs.existsSync(path.join(directory, 'vectors.db'))).toBe(true); + expect(fs.existsSync(path.join(directory, 'history.db'))).toBe(true); + }); + + it('sends nothing to mem0 telemetry and stays out of ~/.mem0', async () => { + const fetchSpy = vi.spyOn(globalThis, 'fetch'); + const store = await createMem0MemoryStore({ directory: tempDir(), embedder: wordEmbedder }); + const [change] = await store.remember({ scope: PERSONAL_SCOPE, text: 'Prefers morning meetings' }); + await store.search('meetings', { scopes: [PERSONAL_SCOPE] }); + await store.list({ scopes: [PERSONAL_SCOPE] }); + await store.update(change.record.id, { importance: 'important' }); + await store.forget(change.record.id); + await store.close(); + expect(fetchSpy).not.toHaveBeenCalled(); + expect(fs.existsSync(path.join(os.homedir(), '.mem0'))).toBe(false); + }); + + it('offers extraction only when a model is configured', async () => { + const store = await createMem0MemoryStore({ directory: tempDir(), embedder: wordEmbedder }); + expect(store.capabilities).toMatchObject({ extraction: false, semanticSearch: true, history: true }); + await store.close(); + }); + + it('extracts facts from a conversation with the configured model', async () => { + const requests: Array<{ model: string; response_format?: { type: string } }> = []; + const server = http.createServer((req, res) => { + let body = ''; + req.on('data', (chunk) => { body += chunk; }); + req.on('end', () => { + requests.push(JSON.parse(body)); + res.setHeader('Content-Type', 'application/json'); + res.end(JSON.stringify({ + id: 'chatcmpl-test', + object: 'chat.completion', + created: 0, + model: 'test-model', + choices: [{ + index: 0, + finish_reason: 'stop', + message: { role: 'assistant', content: JSON.stringify({ memory: [{ text: 'Lives in Novi Sad' }] }) }, + }], + usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }, + })); + }); + }); + await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve)); + const { port } = server.address() as AddressInfo; + try { + const store = await createMem0MemoryStore({ + directory: tempDir(), + embedder: wordEmbedder, + extractionModel: { baseURL: `http://127.0.0.1:${port}/v1`, apiKey: 'test-key', model: 'test-model' }, + }); + expect(store.capabilities.extraction).toBe(true); + const changes = await store.remember({ + scope: PERSONAL_SCOPE, + conversation: [ + { role: 'user', content: 'I moved to Novi Sad last year.' }, + { role: 'assistant', content: 'Noted.' }, + ], + kind: 'profile', + origin: 'chat', + }); + expect(changes).toHaveLength(1); + expect(changes[0]).toMatchObject({ + event: 'added', + record: { text: 'Lives in Novi Sad', scope: PERSONAL_SCOPE, kind: 'profile', origin: 'chat' }, + }); + expect(requests[0]).toMatchObject({ model: 'test-model', response_format: { type: 'json_object' } }); + await store.close(); + } finally { + await new Promise((resolve) => server.close(() => resolve())); + } + }); +}); diff --git a/packages/memory-mem0/tsconfig.json b/packages/memory-mem0/tsconfig.json new file mode 100644 index 0000000..b0c54fe --- /dev/null +++ b/packages/memory-mem0/tsconfig.json @@ -0,0 +1,21 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "moduleResolution": "bundler", + "lib": ["ES2022"], + "outDir": "dist", + "rootDir": "src", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "declaration": true, + "declarationMap": true, + "sourceMap": true, + "composite": true + }, + "include": ["src/**/*.ts"], + "exclude": ["node_modules", "dist", "tests"] +}