@prmichaelsen/remember-mcp 0.2.7 → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,145 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-02-12
+
+### 🚨 BREAKING CHANGES
+
+- **`createServer` is now async**: The factory function now returns `Promise<Server>` instead of `Server`. Consumers must use `await` when calling `createServer()`.
+
+  ```typescript
+  // Before (0.2.x)
+  const server = createServer(token, userId);
+  
+  // After (1.0.0+)
+  const server = await createServer(token, userId);
+  ```
+
+  **Impact**: Only affects direct factory users. The mcp-auth wrapper handles async factories automatically, so no changes needed for mcp-auth users.
+
+### ✨ Added
+
+- **Weaviate v3 Filter API**: Implemented proper Weaviate v3 filter builders using fluent API
+  - Created `src/utils/weaviate-filters.ts` with filter builder utilities
+  - Supports AND/OR logic for complex filter combinations
+  - Comprehensive filter support: type, weight, trust, date range, tags
+
+- **Combined Memory + Relationship Search**: `remember_search_memory` now searches BOTH memories and relationships by default
+  - Uses OR logic to search both doc types
+  - Results separated into `memories` and `relationships` arrays
+  - Backward compatible: set `include_relationships: false` to search only memories
+  - Relationship observations are now searchable
+
+- **Comprehensive Unit Tests**: Added 29 test cases for filter builders
+  - Tests for `buildMemoryOnlyFilters`, `buildRelationshipOnlyFilters`, `buildCombinedSearchFilters`
+  - Tests for edge cases and complex filter scenarios
+  - 83.67% code coverage on weaviate-filters.ts
+
+- **Jest Type Support**: Added "jest" to tsconfig types array for proper TypeScript support in test files
+
+### 🐛 Fixed
+
+- **gRPC Filter Error**: Fixed "paths needs to have an uneven number of components" error
+  - Replaced old Weaviate v2 filter format (path/operator/valueText) with v3 fluent API
+  - Affected tools: `remember_search_memory`, `remember_query_memory`
+
+- **Database Initialization**: Changed from fire-and-forget to await pattern
+  - Server now waits for database initialization before accepting requests
+  - Prevents server from starting in broken state
+  - Errors propagate clearly to caller
+
+- **Test Failures**: Fixed server-factory tests to handle async createServer
+  - Updated all tests to use async/await
+  - Changed synchronous expect() calls to async expect().resolves/rejects
+
+### 📊 Test Results
+
+- **54 tests passing** (up from 25)
+- **4 test suites passing** (all green)
+- **Overall coverage: 26.54%** (up from 22.53%)
+- **1 skipped** (integration test requiring live Weaviate)
+
+### 📝 Documentation
+
+- Updated `agent/progress.yaml` with Task 20 completion
+- Updated `agent/tasks/task-20-fix-weaviate-v3-filters.md` with implementation details
+- All changes documented in agent directory
+
+---
+
+## [0.2.8] - 2026-02-11
+
+### ✨ Added
+
+- Complete memory CRUD operations (create, read, update, delete)
+- Complete relationship CRUD operations (create, read, update, delete)
+- User preferences system with 6 categories
+- 12 MCP tools fully implemented
+- Hybrid search (semantic + keyword)
+- Vector similarity search
+- RAG-optimized queries
+- 45 content types
+
+### 📊 Milestones Completed
+
+- M1: Project Foundation (100%)
+- M2: Core Memory System (100%)
+- M3: Relationships & Graph (100%)
+- M4: User Preferences (100%)
+
+---
+
+## [0.1.0] - 2026-02-11
+
+### ✨ Initial Release
+
+- Project structure and configuration
+- Weaviate client with multi-tenant support
+- Firestore integration
+- Basic MCP server with stdio transport
+- Server factory for mcp-auth compatibility
+- 25 unit tests
+- Dual build: standalone server + library factory
+
+---
+
+## Migration Guides
+
+### Migrating from 0.2.x to 1.0.0
+
+**If you're using the factory export:**
+
+```typescript
+// OLD (0.2.x)
+import { createServer } from '@prmichaelsen/remember-mcp/factory';
+const server = createServer(accessToken, userId);
+
+// NEW (1.0.0+)
+import { createServer } from '@prmichaelsen/remember-mcp/factory';
+const server = await createServer(accessToken, userId);
+```
+
+**If you're using mcp-auth wrapper:**
+- No changes needed! mcp-auth handles async factories automatically.
+
+**If you're using standalone server:**
+- No changes needed! You don't call createServer directly.
+
+**If you're using Claude Desktop:**
+- No changes needed! You use the built server via npx.
+
+---
+
+## Versioning Policy
+
+This project follows [Semantic Versioning](https://semver.org/):
+
+- **Major** (X.0.0): Breaking changes
+- **Minor** (0.X.0): New features, backward compatible
+- **Patch** (0.0.X): Bug fixes, backward compatible
+
+**Note**: Version 1.0.0 indicates the first stable release with a breaking change from 0.2.x. Future breaking changes will increment the major version (2.0.0, 3.0.0, etc.).

package/dist/server-factory.d.ts

@@ -38,5 +38,5 @@ export interface ServerOptions {
  * });
  * ```
  */
-export declare function createServer(accessToken: string, userId: string, options?: ServerOptions): Server;
+export declare function createServer(accessToken: string, userId: string, options?: ServerOptions): Promise<Server>;
 //# sourceMappingURL=server-factory.d.ts.map

package/dist/server-factory.js

@@ -3190,14 +3190,12 @@ async function ensureDatabasesInitialized() {
   })();
   return initializationPromise;
 }
-function createServer(accessToken, userId, options = {}) {
+async function createServer(accessToken, userId, options = {}) {
   if (!userId) {
     throw new Error("userId is required");
   }
   logger.debug("Creating server instance", { userId });
-  ensureDatabasesInitialized().catch((error) => {
-    logger.error("Failed to initialize databases:", error);
-  });
+  await ensureDatabasesInitialized();
   const server = new Server(
     {
       name: options.name || "remember-mcp",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "0.2.7",
+  "version": "1.0.0",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",

package/src/server-factory.spec.ts

@@ -3,24 +3,24 @@ import { createServer } from './server-factory.js';
 
 describe('Server Factory', () => {
   describe('Parameter Validation', () => {
-    it('should create server instance with valid parameters', () => {
-      const server = createServer('test-token', 'user123');
+    it('should create server instance with valid parameters', async () => {
+      const server = await createServer('test-token', 'user123');
       expect(server).toBeDefined();
       expect(server).toHaveProperty('setRequestHandler');
     });
 
-    it('should allow empty accessToken (not used by remember-mcp)', () => {
+    it('should allow empty accessToken (not used by remember-mcp)', async () => {
       // accessToken is not used by remember-mcp (self-managed data)
       // Should not throw even with empty string
-      expect(() => createServer('', 'user123')).not.toThrow();
+      await expect(createServer('', 'user123')).resolves.toBeDefined();
     });
 
-    it('should require userId', () => {
-      expect(() => createServer('token', '')).toThrow('userId is required');
+    it('should require userId', async () => {
+      await expect(createServer('token', '')).rejects.toThrow('userId is required');
     });
 
-    it('should accept custom options', () => {
-      const server = createServer('token', 'user123', {
+    it('should accept custom options', async () => {
+      const server = await createServer('token', 'user123', {
         name: 'custom-name',
         version: '2.0.0',
       });

package/src/server-factory.ts

@@ -113,11 +113,11 @@ async function ensureDatabasesInitialized(): Promise<void> {
  * });
  * ```
  */
-export function createServer(
+export async function createServer(
   accessToken: string,
   userId: string,
   options: ServerOptions = {}
-): Server {
+): Promise<Server> {
   // Note: accessToken is not used by remember-mcp (self-managed data)
   // but required by mcp-auth contract. Can be any value including empty string.
   
@@ -128,11 +128,8 @@ export function createServer(
   logger.debug('Creating server instance', { userId });
   
   // Ensure databases are initialized (happens once globally)
-  // Note: This is synchronous to match the Server return type
-  // The actual initialization happens on first tool call
-  ensureDatabasesInitialized().catch(error => {
-    logger.error('Failed to initialize databases:', error);
-  });
+  // Initialization must succeed or server creation fails
+  await ensureDatabasesInitialized();
   
   // Create MCP server
   const server = new Server(