@prmichaelsen/remember-mcp 3.15.4 → 3.15.6

package/src/tools/get-core.ts

@@ -0,0 +1,109 @@
+/**
+ * remember_get_core tool
+ * Reads the ghost's core state (mood + perception) from Firestore
+ */
+
+import { handleToolError } from '../utils/error-handler.js';
+import { createDebugLogger } from '../utils/debug.js';
+import type { AuthContext } from '../types/auth.js';
+import { getDocument } from '../firestore/init.js';
+import { BASE } from '../firestore/paths.js';
+
+export const getCoreTool = {
+  name: 'remember_get_core',
+  description: `Get the ghost's current emotional state and perception model.
+
+  Returns the ghost's current dimensional state (valence, arousal, confidence,
+  social_warmth, coherence, trust), derived emotion labels (dominant_emotion, color),
+  directional state (motivation, goal, purpose), and active pressure sources.
+
+  Optionally includes the ghost's internal model of a specific user (personality,
+  communication style, interests, patterns, needs).
+
+  Use this for introspection — understanding how the ghost feels and why.
+  The mood state biases memory retrieval and influences ghost behavior.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      include_pressures: {
+        type: 'boolean',
+        description: "Include active pressure sources with reasons. Default: true",
+      },
+      include_perception: {
+        type: 'string',
+        description: "Include the ghost's perception of a specific user (by user_id). Omit to skip. Use owner's user_id for self-perception.",
+      },
+    },
+  },
+};
+
+export interface GetCoreArgs {
+  include_pressures?: boolean;
+  include_perception?: string;
+}
+
+export async function handleGetCore(
+  args: GetCoreArgs,
+  userId: string,
+  _authContext?: AuthContext
+): Promise<string> {
+  const debug = createDebugLogger({ tool: 'remember_get_core', userId, operation: 'get core state' });
+  try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+
+    // Read mood state from Firestore: {BASE}.users/{user_id}/core doc: mood
+    const mood = await getDocument(`${BASE}.users/${userId}/core`, 'mood');
+
+    if (!mood) {
+      return JSON.stringify({
+        mood: null,
+        message: 'No mood state found. Mood is initialized during the first REM cycle.',
+      });
+    }
+
+    const result: any = {
+      mood: {
+        state: mood.state,
+        color: mood.color,
+        dominant_emotion: mood.dominant_emotion,
+        reasoning: mood.reasoning,
+        motivation: mood.motivation,
+        goal: mood.goal,
+        purpose: mood.purpose,
+        last_updated: mood.last_updated,
+        rem_cycles_since_shift: mood.rem_cycles_since_shift,
+      },
+    };
+
+    // Include pressures if requested (default: true)
+    if (args.include_pressures !== false && mood.pressures) {
+      result.mood.pressures = mood.pressures;
+    }
+
+    // Include threshold flags if any are active
+    if (mood.threshold_flags?.length > 0) {
+      result.mood.threshold_flags = mood.threshold_flags;
+    }
+
+    // Include perception if requested
+    if (args.include_perception) {
+      const perception = await getDocument(
+        `${BASE}.users/${userId}/core/perceptions`,
+        args.include_perception,
+      );
+      if (perception) {
+        result.perception = perception;
+      }
+    }
+
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
+    handleToolError(error, {
+      toolName: 'remember_get_core',
+      operation: 'get core state',
+      userId,
+    });
+  }
+}

package/src/tools/ghost-tools.spec.ts

@@ -0,0 +1,361 @@
+import { createGhostMemoryTool, handleCreateGhostMemory } from './create-ghost-memory.js';
+import { updateGhostMemoryTool, handleUpdateGhostMemory } from './update-ghost-memory.js';
+import { searchGhostMemoryTool, handleSearchGhostMemory } from './search-ghost-memory.js';
+import { queryGhostMemoryTool, handleQueryGhostMemory } from './query-ghost-memory.js';
+import { searchGhostMemoryByTool, handleSearchGhostMemoryBy } from './search-ghost-memory-by.js';
+
+// Mock core-services
+const mockCreate = jest.fn();
+const mockUpdate = jest.fn();
+const mockByTime = jest.fn();
+
+jest.mock('../core-services.js', () => ({
+  createCoreServices: jest.fn(() => ({
+    memory: {
+      create: mockCreate,
+      update: mockUpdate,
+      byTime: mockByTime,
+      byDensity: jest.fn().mockResolvedValue({ memories: [], total: 0, offset: 0, limit: 10 }),
+      byRating: jest.fn().mockResolvedValue({ memories: [], total: 0, offset: 0, limit: 10 }),
+      byDiscovery: jest.fn().mockResolvedValue({ memories: [], total: 0, offset: 0, limit: 10 }),
+    },
+  })),
+}));
+
+// Mock search-memory handler
+const mockHandleSearchMemory = jest.fn();
+jest.mock('./search-memory.js', () => ({
+  handleSearchMemory: (...args: any[]) => mockHandleSearchMemory(...args),
+}));
+
+// Mock query-memory handler
+const mockHandleQueryMemory = jest.fn();
+jest.mock('./query-memory.js', () => ({
+  handleQueryMemory: (...args: any[]) => mockHandleQueryMemory(...args),
+}));
+
+// Mock weaviate schema for update-ghost-memory
+const mockFetchObjectById = jest.fn();
+jest.mock('../weaviate/schema.js', () => ({
+  getMemoryCollection: jest.fn(() => ({
+    query: { fetchObjectById: mockFetchObjectById },
+  })),
+}));
+
+jest.mock('../utils/debug.js', () => ({
+  createDebugLogger: () => ({
+    info: jest.fn(),
+    trace: jest.fn(),
+    error: jest.fn(),
+  }),
+}));
+
+describe('Ghost Memory Tools', () => {
+  const userId = 'test-user-1';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockHandleSearchMemory.mockResolvedValue(JSON.stringify({ memories: [], total: 0 }));
+    mockHandleQueryMemory.mockResolvedValue(JSON.stringify({ memories: [], total: 0 }));
+    mockByTime.mockResolvedValue({ memories: [], total: 0, offset: 0, limit: 10 });
+  });
+
+  // ── create_ghost_memory ──
+
+  describe('remember_create_ghost_memory', () => {
+    it('has correct tool name', () => {
+      expect(createGhostMemoryTool.name).toBe('remember_create_ghost_memory');
+    });
+
+    it('requires content', () => {
+      expect(createGhostMemoryTool.inputSchema.required).toContain('content');
+    });
+
+    it('hardcodes content_type to ghost', async () => {
+      mockCreate.mockResolvedValue({ memory_id: 'mem-1', created_at: '2026-01-01' });
+      await handleCreateGhostMemory({ content: 'test ghost' }, userId);
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'ghost' }),
+      );
+    });
+
+    it('adds ghost tag automatically', async () => {
+      mockCreate.mockResolvedValue({ memory_id: 'mem-1', created_at: '2026-01-01' });
+      await handleCreateGhostMemory({ content: 'test' }, userId);
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: expect.arrayContaining(['ghost']),
+        }),
+      );
+    });
+
+    it('adds ghost:{accessor_user_id} tag from auth context', async () => {
+      mockCreate.mockResolvedValue({ memory_id: 'mem-1', created_at: '2026-01-01' });
+      const authContext = {
+        accessToken: 'token',
+        credentials: null,
+        ghostMode: {
+          owner_user_id: 'owner-123',
+          accessor_user_id: 'accessor-456',
+          accessor_trust_level: 0.7,
+        },
+      };
+      await handleCreateGhostMemory({ content: 'test' }, userId, authContext);
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: expect.arrayContaining(['ghost', 'ghost:accessor-456']),
+        }),
+      );
+    });
+
+    it('merges user tags without duplicating ghost', async () => {
+      mockCreate.mockResolvedValue({ memory_id: 'mem-1', created_at: '2026-01-01' });
+      await handleCreateGhostMemory({ content: 'test', tags: ['ghost', 'custom'] }, userId);
+      const callArgs = mockCreate.mock.calls[0][0];
+      const ghostCount = callArgs.tags.filter((t: string) => t === 'ghost').length;
+      expect(ghostCount).toBe(1);
+      expect(callArgs.tags).toContain('custom');
+    });
+
+    it('returns memory_id and content_type in response', async () => {
+      mockCreate.mockResolvedValue({ memory_id: 'mem-1', created_at: '2026-01-01' });
+      const result = await handleCreateGhostMemory({ content: 'test' }, userId);
+      const parsed = JSON.parse(result);
+      expect(parsed.memory_id).toBe('mem-1');
+      expect(parsed.content_type).toBe('ghost');
+    });
+
+    it('passes feel_* fields through', async () => {
+      mockCreate.mockResolvedValue({ memory_id: 'mem-1', created_at: '2026-01-01' });
+      await handleCreateGhostMemory(
+        { content: 'test', feel_salience: 0.8, feel_social_weight: 0.5 },
+        userId,
+      );
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({ feel_salience: 0.8, feel_social_weight: 0.5 }),
+      );
+    });
+  });
+
+  // ── update_ghost_memory ──
+
+  describe('remember_update_ghost_memory', () => {
+    it('has correct tool name', () => {
+      expect(updateGhostMemoryTool.name).toBe('remember_update_ghost_memory');
+    });
+
+    it('requires memory_id', () => {
+      expect(updateGhostMemoryTool.inputSchema.required).toContain('memory_id');
+    });
+
+    it('rejects non-ghost memories', async () => {
+      mockFetchObjectById.mockResolvedValue({
+        properties: { content_type: 'note' },
+      });
+      const result = await handleUpdateGhostMemory(
+        { memory_id: 'mem-1', content: 'updated' },
+        userId,
+      );
+      const parsed = JSON.parse(result);
+      expect(parsed.error).toContain('not a ghost memory');
+    });
+
+    it('returns error for non-existent memory', async () => {
+      mockFetchObjectById.mockResolvedValue(null);
+      const result = await handleUpdateGhostMemory(
+        { memory_id: 'mem-missing' },
+        userId,
+      );
+      const parsed = JSON.parse(result);
+      expect(parsed.error).toContain('not found');
+    });
+
+    it('updates ghost memory successfully', async () => {
+      mockFetchObjectById.mockResolvedValue({
+        properties: { content_type: 'ghost' },
+      });
+      mockUpdate.mockResolvedValue({
+        memory_id: 'mem-1',
+        updated_at: '2026-01-01',
+        version: 2,
+        updated_fields: ['content'],
+      });
+      const result = await handleUpdateGhostMemory(
+        { memory_id: 'mem-1', content: 'updated ghost' },
+        userId,
+      );
+      const parsed = JSON.parse(result);
+      expect(parsed.memory_id).toBe('mem-1');
+      expect(parsed.updated_fields).toContain('content');
+    });
+  });
+
+  // ── search_ghost_memory ──
+
+  describe('remember_search_ghost_memory', () => {
+    it('has correct tool name', () => {
+      expect(searchGhostMemoryTool.name).toBe('remember_search_ghost_memory');
+    });
+
+    it('requires query', () => {
+      expect(searchGhostMemoryTool.inputSchema.required).toContain('query');
+    });
+
+    it('hardcodes filters.types to ghost', async () => {
+      await handleSearchGhostMemory({ query: 'test' }, userId);
+      expect(mockHandleSearchMemory).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filters: expect.objectContaining({ types: ['ghost'] }),
+        }),
+        userId,
+        undefined,
+      );
+    });
+
+    it('passes query and alpha through', async () => {
+      await handleSearchGhostMemory({ query: 'hello', alpha: 0.5 }, userId);
+      expect(mockHandleSearchMemory).toHaveBeenCalledWith(
+        expect.objectContaining({ query: 'hello', alpha: 0.5 }),
+        userId,
+        undefined,
+      );
+    });
+
+    it('passes tags through in filters', async () => {
+      await handleSearchGhostMemory({ query: 'test', tags: ['important'] }, userId);
+      expect(mockHandleSearchMemory).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filters: expect.objectContaining({ tags: ['important'], types: ['ghost'] }),
+        }),
+        userId,
+        undefined,
+      );
+    });
+
+    it('passes limit and offset', async () => {
+      await handleSearchGhostMemory({ query: 'test', limit: 20, offset: 5 }, userId);
+      expect(mockHandleSearchMemory).toHaveBeenCalledWith(
+        expect.objectContaining({ limit: 20, offset: 5 }),
+        userId,
+        undefined,
+      );
+    });
+
+    it('passes deleted_filter', async () => {
+      await handleSearchGhostMemory({ query: 'test', deleted_filter: 'only' }, userId);
+      expect(mockHandleSearchMemory).toHaveBeenCalledWith(
+        expect.objectContaining({ deleted_filter: 'only' }),
+        userId,
+        undefined,
+      );
+    });
+  });
+
+  // ── query_ghost_memory ──
+
+  describe('remember_query_ghost_memory', () => {
+    it('has correct tool name', () => {
+      expect(queryGhostMemoryTool.name).toBe('remember_query_ghost_memory');
+    });
+
+    it('requires query', () => {
+      expect(queryGhostMemoryTool.inputSchema.required).toContain('query');
+    });
+
+    it('hardcodes filters.types to ghost', async () => {
+      await handleQueryGhostMemory({ query: 'what happened?' }, userId);
+      expect(mockHandleQueryMemory).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filters: expect.objectContaining({ types: ['ghost'] }),
+        }),
+        userId,
+        undefined,
+      );
+    });
+
+    it('passes query through', async () => {
+      await handleQueryGhostMemory({ query: 'tell me about interactions' }, userId);
+      expect(mockHandleQueryMemory).toHaveBeenCalledWith(
+        expect.objectContaining({ query: 'tell me about interactions' }),
+        userId,
+        undefined,
+      );
+    });
+
+    it('passes limit and min_relevance', async () => {
+      await handleQueryGhostMemory({ query: 'test', limit: 10, min_relevance: 0.8 }, userId);
+      expect(mockHandleQueryMemory).toHaveBeenCalledWith(
+        expect.objectContaining({ limit: 10, min_relevance: 0.8 }),
+        userId,
+        undefined,
+      );
+    });
+
+    it('passes authContext through', async () => {
+      const authContext = {
+        accessToken: 'token',
+        credentials: null,
+        ghostMode: {
+          owner_user_id: 'owner-123',
+          accessor_user_id: 'accessor-456',
+          accessor_trust_level: 0.7,
+        },
+      };
+      await handleQueryGhostMemory({ query: 'test' }, userId, authContext);
+      expect(mockHandleQueryMemory).toHaveBeenCalledWith(
+        expect.anything(),
+        userId,
+        authContext,
+      );
+    });
+  });
+
+  // ── search_ghost_memory_by ──
+
+  describe('remember_search_ghost_memory_by', () => {
+    it('has correct tool name', () => {
+      expect(searchGhostMemoryByTool.name).toBe('remember_search_ghost_memory_by');
+    });
+
+    it('requires mode', () => {
+      expect(searchGhostMemoryByTool.inputSchema.required).toContain('mode');
+    });
+
+    it('hardcodes filters.types to ghost for byTime', async () => {
+      await handleSearchGhostMemoryBy({ mode: 'byTime' }, userId);
+      expect(mockByTime).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filters: expect.objectContaining({ types: ['ghost'] }),
+        }),
+      );
+    });
+
+    it('passes sort_order through', async () => {
+      await handleSearchGhostMemoryBy({ mode: 'byTime', sort_order: 'asc' }, userId);
+      expect(mockByTime).toHaveBeenCalledWith(
+        expect.objectContaining({ direction: 'asc' }),
+      );
+    });
+
+    it('passes limit and offset', async () => {
+      await handleSearchGhostMemoryBy({ mode: 'byTime', limit: 20, offset: 5 }, userId);
+      expect(mockByTime).toHaveBeenCalledWith(
+        expect.objectContaining({ limit: 20, offset: 5 }),
+      );
+    });
+
+    it('passes deleted_filter', async () => {
+      await handleSearchGhostMemoryBy({ mode: 'byTime', deleted_filter: 'only' }, userId);
+      expect(mockByTime).toHaveBeenCalledWith(
+        expect.objectContaining({ deleted_filter: 'only' }),
+      );
+    });
+
+    it('has all mode options in schema', () => {
+      const modeProp = (searchGhostMemoryByTool.inputSchema.properties as any).mode;
+      expect(modeProp.enum).toEqual(
+        expect.arrayContaining(['byTime', 'byDensity', 'byRating', 'byDiscovery', 'byProperty', 'bySignificance', 'byRandom', 'byBroad']),
+      );
+    });
+  });
+});

package/src/tools/query-ghost-memory.ts

@@ -0,0 +1,63 @@
+/**
+ * remember_query_ghost_memory tool
+ * Wraps query_memory with hardcoded ghost type filter
+ */
+
+import { handleToolError } from '../utils/error-handler.js';
+import { createDebugLogger } from '../utils/debug.js';
+import type { AuthContext } from '../types/auth.js';
+import { handleQueryMemory } from './query-memory.js';
+
+export const queryGhostMemoryTool = {
+  name: 'remember_query_ghost_memory',
+  description: `Query ghost memories using natural language (pure semantic search).
+  Automatically filters to content_type: ghost.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Natural language question' },
+      limit: { type: 'number', description: 'Max results. Default: 5' },
+      min_relevance: { type: 'number', description: 'Minimum relevance score. Default: 0.6' },
+    },
+    required: ['query'],
+  },
+};
+
+export interface QueryGhostMemoryArgs {
+  query: string;
+  limit?: number;
+  min_relevance?: number;
+}
+
+export async function handleQueryGhostMemory(
+  args: QueryGhostMemoryArgs,
+  userId: string,
+  authContext?: AuthContext
+): Promise<string> {
+  const debug = createDebugLogger({ tool: 'remember_query_ghost_memory', userId, operation: 'query ghost memories' });
+  try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+
+    // Delegate to query_memory with ghost type filter hardcoded
+    return await handleQueryMemory(
+      {
+        query: args.query,
+        limit: args.limit,
+        min_relevance: args.min_relevance,
+        filters: {
+          types: ['ghost'] as any,
+        },
+      },
+      userId,
+      authContext
+    );
+  } catch (error) {
+    debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
+    handleToolError(error, {
+      toolName: 'remember_query_ghost_memory',
+      operation: 'query ghost memories',
+      userId,
+    });
+  }
+}

package/src/tools/query-memory.ts

@@ -102,6 +102,10 @@ export const queryMemoryTool = {
             type: 'string',
             description: 'End date (ISO 8601)',
           },
+          rating_min: {
+            type: 'number',
+            description: 'Minimum Bayesian rating average',
+          },
         },
       },
       include_context: {