@prmichaelsen/remember-mcp 3.0.0 → 3.12.0

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

@@ -0,0 +1,180 @@
+import { ghostConfigTool, handleGhostConfig } from './ghost-config.js';
+import * as ghostConfigService from '../services/ghost-config.service';
+import { DEFAULT_GHOST_CONFIG } from '../types/ghost-config.js';
+
+jest.mock('../services/ghost-config.service', () => ({
+  getGhostConfig: jest.fn(),
+  setGhostConfigFields: jest.fn(),
+  setUserTrust: jest.fn(),
+  removeUserTrust: jest.fn(),
+  blockUser: jest.fn(),
+  unblockUser: jest.fn(),
+  validateGhostConfigUpdate: jest.fn(),
+}));
+
+const mockGetGhostConfig = ghostConfigService.getGhostConfig as jest.MockedFunction<typeof ghostConfigService.getGhostConfig>;
+const mockSetGhostConfigFields = ghostConfigService.setGhostConfigFields as jest.MockedFunction<typeof ghostConfigService.setGhostConfigFields>;
+const mockSetUserTrust = ghostConfigService.setUserTrust as jest.MockedFunction<typeof ghostConfigService.setUserTrust>;
+const mockRemoveUserTrust = ghostConfigService.removeUserTrust as jest.MockedFunction<typeof ghostConfigService.removeUserTrust>;
+const mockBlockUser = ghostConfigService.blockUser as jest.MockedFunction<typeof ghostConfigService.blockUser>;
+const mockUnblockUser = ghostConfigService.unblockUser as jest.MockedFunction<typeof ghostConfigService.unblockUser>;
+const mockValidate = ghostConfigService.validateGhostConfigUpdate as jest.MockedFunction<typeof ghostConfigService.validateGhostConfigUpdate>;
+
+describe('remember_ghost_config', () => {
+  const userId = 'test-user-1';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('tool definition', () => {
+    it('has correct name', () => {
+      expect(ghostConfigTool.name).toBe('remember_ghost_config');
+    });
+
+    it('requires action parameter', () => {
+      expect(ghostConfigTool.inputSchema.required).toContain('action');
+    });
+
+    it('has all action options', () => {
+      const actionProp = (ghostConfigTool.inputSchema.properties as any).action;
+      expect(actionProp.enum).toEqual(['get', 'set', 'set_trust', 'remove_trust', 'block', 'unblock']);
+    });
+  });
+
+  describe('get action', () => {
+    it('returns current ghost config', async () => {
+      mockGetGhostConfig.mockResolvedValue({ ...DEFAULT_GHOST_CONFIG });
+
+      const result = await handleGhostConfig({ action: 'get' }, userId);
+      const parsed = JSON.parse(result);
+
+      expect(parsed.success).toBe(true);
+      expect(parsed.config).toEqual(DEFAULT_GHOST_CONFIG);
+      expect(parsed.trust_tier_guide).toBeDefined();
+    });
+  });
+
+  describe('set action', () => {
+    it('updates ghost config', async () => {
+      const updated = { ...DEFAULT_GHOST_CONFIG, enabled: true };
+      mockSetGhostConfigFields.mockResolvedValue(updated);
+
+      const result = await handleGhostConfig({ action: 'set', enabled: true }, userId);
+      const parsed = JSON.parse(result);
+
+      expect(parsed.success).toBe(true);
+      expect(parsed.updated_fields).toContain('enabled');
+      expect(mockValidate).toHaveBeenCalled();
+      expect(mockSetGhostConfigFields).toHaveBeenCalledWith(userId, { enabled: true });
+    });
+
+    it('throws when no fields provided', async () => {
+      await expect(handleGhostConfig({ action: 'set' }, userId))
+        .rejects.toThrow('No fields to update');
+    });
+
+    it('updates multiple fields', async () => {
+      const updated = { ...DEFAULT_GHOST_CONFIG, enabled: true, default_friend_trust: 0.5 };
+      mockSetGhostConfigFields.mockResolvedValue(updated);
+
+      const result = await handleGhostConfig({
+        action: 'set',
+        enabled: true,
+        default_friend_trust: 0.5,
+      }, userId);
+      const parsed = JSON.parse(result);
+
+      expect(parsed.updated_fields).toHaveLength(2);
+    });
+  });
+
+  describe('set_trust action', () => {
+    it('sets per-user trust', async () => {
+      mockSetUserTrust.mockResolvedValue(undefined);
+
+      const result = await handleGhostConfig({
+        action: 'set_trust',
+        target_user_id: 'friend-1',
+        trust_level: 0.75,
+      }, userId);
+      const parsed = JSON.parse(result);
+
+      expect(parsed.success).toBe(true);
+      expect(parsed.trust_level).toBe(0.75);
+      expect(mockSetUserTrust).toHaveBeenCalledWith(userId, 'friend-1', 0.75);
+    });
+
+    it('throws without target_user_id', async () => {
+      await expect(handleGhostConfig({ action: 'set_trust', trust_level: 0.5 }, userId))
+        .rejects.toThrow('target_user_id is required');
+    });
+
+    it('throws without trust_level', async () => {
+      await expect(handleGhostConfig({ action: 'set_trust', target_user_id: 'friend-1' }, userId))
+        .rejects.toThrow('trust_level is required');
+    });
+  });
+
+  describe('remove_trust action', () => {
+    it('removes per-user trust override', async () => {
+      mockRemoveUserTrust.mockResolvedValue(undefined);
+
+      const result = await handleGhostConfig({
+        action: 'remove_trust',
+        target_user_id: 'friend-1',
+      }, userId);
+      const parsed = JSON.parse(result);
+
+      expect(parsed.success).toBe(true);
+      expect(mockRemoveUserTrust).toHaveBeenCalledWith(userId, 'friend-1');
+    });
+
+    it('throws without target_user_id', async () => {
+      await expect(handleGhostConfig({ action: 'remove_trust' }, userId))
+        .rejects.toThrow('target_user_id is required');
+    });
+  });
+
+  describe('block action', () => {
+    it('blocks a user', async () => {
+      mockBlockUser.mockResolvedValue(undefined);
+
+      const result = await handleGhostConfig({
+        action: 'block',
+        target_user_id: 'bad-user',
+      }, userId);
+      const parsed = JSON.parse(result);
+
+      expect(parsed.success).toBe(true);
+      expect(mockBlockUser).toHaveBeenCalledWith(userId, 'bad-user');
+    });
+
+    it('throws without target_user_id', async () => {
+      await expect(handleGhostConfig({ action: 'block' }, userId))
+        .rejects.toThrow('target_user_id is required');
+    });
+  });
+
+  describe('unblock action', () => {
+    it('unblocks a user', async () => {
+      mockUnblockUser.mockResolvedValue(undefined);
+
+      const result = await handleGhostConfig({
+        action: 'unblock',
+        target_user_id: 'bad-user',
+      }, userId);
+      const parsed = JSON.parse(result);
+
+      expect(parsed.success).toBe(true);
+      expect(mockUnblockUser).toHaveBeenCalledWith(userId, 'bad-user');
+    });
+  });
+
+  describe('invalid action', () => {
+    it('throws on unknown action', async () => {
+      await expect(handleGhostConfig({ action: 'invalid' as any }, userId))
+        .rejects.toThrow('Unknown action');
+    });
+  });
+});

package/src/tools/ghost-config.ts

@@ -0,0 +1,230 @@
+/**
+ * remember_ghost_config tool
+ *
+ * Manage ghost/persona configuration: enable/disable ghost,
+ * set trust defaults, manage per-user trust, block/unblock users.
+ */
+
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { handleToolError } from '../utils/error-handler.js';
+import { createDebugLogger } from '../utils/debug.js';
+import type { AuthContext } from '../types/auth.js';
+import type { TrustEnforcementMode } from '../types/ghost-config.js';
+import {
+  getGhostConfig,
+  setGhostConfigFields,
+  setUserTrust,
+  removeUserTrust,
+  blockUser,
+  unblockUser,
+  validateGhostConfigUpdate,
+} from '../services/ghost-config.service.js';
+
+type GhostConfigAction = 'get' | 'set' | 'set_trust' | 'remove_trust' | 'block' | 'unblock';
+
+export const ghostConfigTool: Tool = {
+  name: 'remember_ghost_config',
+  description: `Manage ghost/persona configuration. Controls who can interact with your ghost and at what trust level.
+
+Actions:
+- get: View current ghost configuration
+- set: Update ghost settings (enabled, trust defaults, enforcement mode)
+- set_trust: Set a per-user trust level override (0-1)
+- remove_trust: Remove a per-user trust override (revert to default)
+- block: Block a user from ghost access entirely
+- unblock: Unblock a previously blocked user
+
+Trust levels control what information your ghost can share:
+- 0.0: Existence only ("A memory exists about this")
+- 0.25: Metadata only (tags, type, dates — no content)
+- 0.5: Summary only (AI-generated summary, no raw content)
+- 0.75: Partial access (content with sensitive fields redacted)
+- 1.0: Full access (all content revealed)
+
+Ghost is disabled by default. Enable it to allow others to chat with your AI representation.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['get', 'set', 'set_trust', 'remove_trust', 'block', 'unblock'],
+        description: 'Action to perform',
+      },
+      // For 'set' action
+      enabled: {
+        type: 'boolean',
+        description: 'Enable/disable ghost conversations (for "set" action)',
+      },
+      public_ghost_enabled: {
+        type: 'boolean',
+        description: 'Allow non-friends to chat with ghost (for "set" action)',
+      },
+      default_friend_trust: {
+        type: 'number',
+        description: 'Default trust level for friends (0-1, for "set" action)',
+        minimum: 0,
+        maximum: 1,
+      },
+      default_public_trust: {
+        type: 'number',
+        description: 'Default trust level for strangers (0-1, for "set" action)',
+        minimum: 0,
+        maximum: 1,
+      },
+      enforcement_mode: {
+        type: 'string',
+        enum: ['query', 'prompt', 'hybrid'],
+        description: 'Trust enforcement mode (for "set" action). "query" (default) is most secure.',
+      },
+      // For 'set_trust' / 'remove_trust' / 'block' / 'unblock' actions
+      target_user_id: {
+        type: 'string',
+        description: 'Target user ID (for set_trust, remove_trust, block, unblock)',
+      },
+      trust_level: {
+        type: 'number',
+        description: 'Trust level to assign (0-1, for "set_trust" action)',
+        minimum: 0,
+        maximum: 1,
+      },
+    },
+    required: ['action'],
+  },
+};
+
+interface GhostConfigArgs {
+  action: GhostConfigAction;
+  enabled?: boolean;
+  public_ghost_enabled?: boolean;
+  default_friend_trust?: number;
+  default_public_trust?: number;
+  enforcement_mode?: TrustEnforcementMode;
+  target_user_id?: string;
+  trust_level?: number;
+}
+
+/**
+ * Handle remember_ghost_config tool
+ */
+export async function handleGhostConfig(
+  args: GhostConfigArgs,
+  userId: string,
+  authContext?: AuthContext
+): Promise<string> {
+  const debug = createDebugLogger({ tool: 'remember_ghost_config', userId, operation: args.action });
+  try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+
+    switch (args.action) {
+      case 'get': {
+        const config = await getGhostConfig(userId);
+        return JSON.stringify({
+          success: true,
+          config,
+          trust_tier_guide: {
+            '0.0': 'Existence only',
+            '0.25': 'Metadata only (default friend trust)',
+            '0.5': 'Summary only',
+            '0.75': 'Partial access',
+            '1.0': 'Full access',
+          },
+        }, null, 2);
+      }
+
+      case 'set': {
+        const updates: any = {};
+        if (args.enabled !== undefined) updates.enabled = args.enabled;
+        if (args.public_ghost_enabled !== undefined) updates.public_ghost_enabled = args.public_ghost_enabled;
+        if (args.default_friend_trust !== undefined) updates.default_friend_trust = args.default_friend_trust;
+        if (args.default_public_trust !== undefined) updates.default_public_trust = args.default_public_trust;
+        if (args.enforcement_mode !== undefined) updates.enforcement_mode = args.enforcement_mode;
+
+        if (Object.keys(updates).length === 0) {
+          throw new Error('No fields to update. Provide at least one of: enabled, public_ghost_enabled, default_friend_trust, default_public_trust, enforcement_mode');
+        }
+
+        validateGhostConfigUpdate(updates);
+        const config = await setGhostConfigFields(userId, updates);
+
+        return JSON.stringify({
+          success: true,
+          message: 'Ghost configuration updated',
+          updated_fields: Object.keys(updates),
+          config,
+        }, null, 2);
+      }
+
+      case 'set_trust': {
+        if (!args.target_user_id) {
+          throw new Error('target_user_id is required for set_trust action');
+        }
+        if (args.trust_level === undefined) {
+          throw new Error('trust_level is required for set_trust action');
+        }
+
+        await setUserTrust(userId, args.target_user_id, args.trust_level);
+
+        return JSON.stringify({
+          success: true,
+          message: `Trust level for ${args.target_user_id} set to ${args.trust_level}`,
+          target_user_id: args.target_user_id,
+          trust_level: args.trust_level,
+        }, null, 2);
+      }
+
+      case 'remove_trust': {
+        if (!args.target_user_id) {
+          throw new Error('target_user_id is required for remove_trust action');
+        }
+
+        await removeUserTrust(userId, args.target_user_id);
+
+        return JSON.stringify({
+          success: true,
+          message: `Trust override for ${args.target_user_id} removed (reverted to default)`,
+          target_user_id: args.target_user_id,
+        }, null, 2);
+      }
+
+      case 'block': {
+        if (!args.target_user_id) {
+          throw new Error('target_user_id is required for block action');
+        }
+
+        await blockUser(userId, args.target_user_id);
+
+        return JSON.stringify({
+          success: true,
+          message: `${args.target_user_id} blocked from ghost access`,
+          target_user_id: args.target_user_id,
+        }, null, 2);
+      }
+
+      case 'unblock': {
+        if (!args.target_user_id) {
+          throw new Error('target_user_id is required for unblock action');
+        }
+
+        await unblockUser(userId, args.target_user_id);
+
+        return JSON.stringify({
+          success: true,
+          message: `${args.target_user_id} unblocked from ghost access`,
+          target_user_id: args.target_user_id,
+        }, null, 2);
+      }
+
+      default:
+        throw new Error(`Unknown action: ${args.action}. Valid actions: get, set, set_trust, remove_trust, block, unblock`);
+    }
+  } catch (error) {
+    debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
+    handleToolError(error, {
+      toolName: 'remember_ghost_config',
+      operation: args.action,
+      userId,
+    });
+    throw error; // handleToolError may not throw
+  }
+}

package/src/tools/moderate.spec.ts

@@ -0,0 +1,277 @@
+/**
+ * Tests for remember_moderate tool.
+ */
+
+import { moderateTool, handleModerate } from './moderate.js';
+import type { AuthContext, GroupPermissions } from '../types/auth.js';
+
+// ─── Mocks ───────────────────────────────────────────────────
+
+const mockUpdate = jest.fn().mockResolvedValue(undefined);
+
+jest.mock('../weaviate/client.js', () => ({
+  getWeaviateClient: jest.fn(() => ({
+    collections: {
+      get: jest.fn().mockReturnValue({
+        data: { update: jest.fn().mockResolvedValue(undefined) },
+      }),
+    },
+  })),
+  fetchMemoryWithAllProperties: jest.fn(),
+}));
+
+jest.mock('../weaviate/space-schema.js', () => ({
+  ensurePublicCollection: jest.fn(),
+}));
+
+jest.mock('../utils/logger.js', () => ({
+  logger: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+
+jest.mock('../utils/debug.js', () => ({
+  createDebugLogger: jest.fn(() => ({
+    info: jest.fn(),
+    debug: jest.fn(),
+    trace: jest.fn(),
+    error: jest.fn(),
+    time: jest.fn((_: string, fn: () => any) => fn()),
+  })),
+}));
+
+jest.mock('../collections/dot-notation.js', () => ({
+  CollectionType: { GROUPS: 'groups' },
+  getCollectionName: jest.fn((_: string, id: string) => `Memory_groups_${id}`),
+}));
+
+jest.mock('../utils/error-handler.js', () => ({
+  handleToolError: jest.fn(() => '{"success":false,"error":"internal"}'),
+}));
+
+import { getWeaviateClient, fetchMemoryWithAllProperties } from '../weaviate/client.js';
+import { ensurePublicCollection } from '../weaviate/space-schema.js';
+
+const mockFetchMemory = fetchMemoryWithAllProperties as jest.MockedFunction<any>;
+const mockGetWeaviateClient = getWeaviateClient as jest.MockedFunction<any>;
+const mockEnsurePublicCollection = ensurePublicCollection as jest.MockedFunction<any>;
+
+// ─── Helpers ─────────────────────────────────────────────────
+
+const BASE_PERMISSIONS: GroupPermissions = {
+  can_read: true,
+  can_publish: true,
+  can_revise: false,
+  can_propose: false,
+  can_overwrite: false,
+  can_comment: true,
+  can_retract_own: true,
+  can_retract_any: false,
+  can_manage_members: false,
+  can_moderate: false,
+};
+
+function makeModeratorAuth(groupId: string): AuthContext {
+  return {
+    accessToken: 'tok',
+    credentials: {
+      user_id: 'moderator-1',
+      group_memberships: [{
+        group_id: groupId,
+        permissions: { ...BASE_PERMISSIONS, can_moderate: true },
+      }],
+    },
+  };
+}
+
+function makeNonModeratorAuth(): AuthContext {
+  return {
+    accessToken: 'tok',
+    credentials: {
+      user_id: 'user-1',
+      group_memberships: [{
+        group_id: 'some-group',
+        permissions: { ...BASE_PERMISSIONS, can_moderate: false },
+      }],
+    },
+  };
+}
+
+const PUBLISHED_MEMORY = {
+  properties: {
+    content: 'Published memory',
+    moderation_status: 'pending',
+    author_id: 'author-1',
+  },
+};
+
+// ─── Tests ───────────────────────────────────────────────────
+
+describe('moderateTool definition', () => {
+  it('has correct tool name', () => {
+    expect(moderateTool.name).toBe('remember_moderate');
+  });
+
+  it('requires memory_id and action', () => {
+    expect(moderateTool.inputSchema.required).toEqual(['memory_id', 'action']);
+  });
+
+  it('has action enum with approve, reject, remove', () => {
+    const props = moderateTool.inputSchema.properties as Record<string, any>;
+    expect(props.action.enum).toEqual(['approve', 'reject', 'remove']);
+  });
+});
+
+describe('handleModerate', () => {
+  let groupUpdate: jest.Mock;
+  let spaceUpdate: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    groupUpdate = jest.fn().mockResolvedValue(undefined);
+    spaceUpdate = jest.fn().mockResolvedValue(undefined);
+
+    mockGetWeaviateClient.mockReturnValue({
+      collections: {
+        get: jest.fn().mockReturnValue({
+          data: { update: groupUpdate },
+        }),
+      },
+    });
+
+    mockEnsurePublicCollection.mockResolvedValue({
+      data: { update: spaceUpdate },
+    });
+
+    mockFetchMemory.mockResolvedValue(PUBLISHED_MEMORY);
+  });
+
+  it('returns error when no space_id or group_id provided', async () => {
+    const result = JSON.parse(
+      await handleModerate({ memory_id: 'mem-1', action: 'approve' }, 'mod-1', makeModeratorAuth('g1'))
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Missing destination');
+  });
+
+  it('returns permission error for non-moderator on group', async () => {
+    const result = JSON.parse(
+      await handleModerate(
+        { memory_id: 'mem-1', action: 'approve', group_id: 'team-1' },
+        'user-1',
+        makeNonModeratorAuth()
+      )
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Permission denied');
+  });
+
+  it('returns permission error for non-moderator on space', async () => {
+    const result = JSON.parse(
+      await handleModerate(
+        { memory_id: 'mem-1', action: 'approve', space_id: 'public' },
+        'user-1',
+        makeNonModeratorAuth()
+      )
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Permission denied');
+  });
+
+  it('returns error when memory not found', async () => {
+    mockFetchMemory.mockResolvedValue(null);
+
+    const result = JSON.parse(
+      await handleModerate(
+        { memory_id: 'missing', action: 'approve', group_id: 'g1' },
+        'mod-1',
+        makeModeratorAuth('g1')
+      )
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Memory not found');
+  });
+
+  it('approves a memory in a group', async () => {
+    const result = JSON.parse(
+      await handleModerate(
+        { memory_id: 'mem-1', action: 'approve', group_id: 'g1' },
+        'mod-1',
+        makeModeratorAuth('g1')
+      )
+    );
+    expect(result.success).toBe(true);
+    expect(result.moderation_status).toBe('approved');
+    expect(result.moderated_by).toBe('mod-1');
+    expect(result.moderated_at).toBeDefined();
+
+    expect(groupUpdate).toHaveBeenCalledWith({
+      id: 'mem-1',
+      properties: expect.objectContaining({
+        moderation_status: 'approved',
+        moderated_by: 'mod-1',
+      }),
+    });
+  });
+
+  it('rejects a memory in a group', async () => {
+    const result = JSON.parse(
+      await handleModerate(
+        { memory_id: 'mem-1', action: 'reject', group_id: 'g1', reason: 'Spam' },
+        'mod-1',
+        makeModeratorAuth('g1')
+      )
+    );
+    expect(result.success).toBe(true);
+    expect(result.moderation_status).toBe('rejected');
+    expect(result.reason).toBe('Spam');
+  });
+
+  it('removes a memory in a group', async () => {
+    const result = JSON.parse(
+      await handleModerate(
+        { memory_id: 'mem-1', action: 'remove', group_id: 'g1' },
+        'mod-1',
+        makeModeratorAuth('g1')
+      )
+    );
+    expect(result.success).toBe(true);
+    expect(result.moderation_status).toBe('removed');
+  });
+
+  it('moderates a memory in a space', async () => {
+    const result = JSON.parse(
+      await handleModerate(
+        { memory_id: 'mem-1', action: 'approve', space_id: 'public' },
+        'mod-1',
+        makeModeratorAuth('some-group')
+      )
+    );
+    expect(result.success).toBe(true);
+    expect(result.moderation_status).toBe('approved');
+    expect(result.location).toBe('space:public');
+
+    expect(spaceUpdate).toHaveBeenCalledWith({
+      id: 'mem-1',
+      properties: expect.objectContaining({
+        moderation_status: 'approved',
+        moderated_by: 'mod-1',
+      }),
+    });
+  });
+
+  it('sets moderated_at to a valid ISO date', async () => {
+    const before = new Date().toISOString();
+
+    const result = JSON.parse(
+      await handleModerate(
+        { memory_id: 'mem-1', action: 'approve', group_id: 'g1' },
+        'mod-1',
+        makeModeratorAuth('g1')
+      )
+    );
+
+    const after = new Date().toISOString();
+    expect(result.moderated_at >= before).toBe(true);
+    expect(result.moderated_at <= after).toBe(true);
+  });
+});