@gethmy/mcp 2.4.7 → 2.5.1

package/src/__tests__/integration-memory-system.test.ts

@@ -1,321 +0,0 @@
-/**
- * Integration tests for the Intelligent Agent Memory System.
- *
- * These tests exercise the MCP tools end-to-end via the Harmony API.
- * Prerequisites:
- *   1. `supabase db push` (migration applied)
- *   2. MCP server configured with valid API key
- *   3. Active workspace and project set
- *
- * Run with: bun test packages/mcp-server/src/__tests__/integration-memory-system.test.ts
- *
- * These tests create real entities and clean them up afterwards.
- * If a test fails mid-way, you may need to manually delete leftover entities.
- */
-
-import { afterAll, describe, expect, test } from "bun:test";
-import { getClient } from "../api-client.js";
-import {
-  getActiveProjectId,
-  getActiveWorkspaceId,
-  isConfigured,
-  loadConfig,
-} from "../config.js";
-
-// Track entities created during tests for cleanup
-const createdEntityIds: string[] = [];
-
-// Skip all tests if MCP server isn't configured
-const configured = (() => {
-  try {
-    loadConfig();
-    return isConfigured() && !!getActiveWorkspaceId();
-  } catch {
-    return false;
-  }
-})();
-
-// Check if the tier migration has been applied by testing a create
-const migrationApplied = await (async () => {
-  if (!configured) return false;
-  try {
-    const client = getClient();
-    const result = await client.createMemoryEntity({
-      workspace_id: getActiveWorkspaceId()!,
-      project_id: getActiveProjectId() || undefined,
-      type: "context",
-      scope: getActiveProjectId() ? "project" : "workspace",
-      memory_tier: "draft",
-      title: "[TEST] Migration check - delete me",
-      content: "Checking if memory_tier column exists.",
-      agent_identifier: "test-runner",
-    });
-    const entity = result.entity as Record<string, unknown>;
-    const hasTier = entity.memory_tier === "draft";
-    // Clean up probe entity
-    if (entity.id) {
-      await client.deleteMemoryEntity(entity.id as string).catch(() => {});
-    }
-    return hasTier;
-  } catch {
-    return false;
-  }
-})();
-
-const describeIf = configured ? describe : describe.skip;
-const describeIfMigrated =
-  configured && migrationApplied ? describe : describe.skip;
-
-// Cleanup: delete all test entities
-afterAll(async () => {
-  if (!configured || createdEntityIds.length === 0) return;
-  const client = getClient();
-  for (const id of createdEntityIds) {
-    try {
-      await client.deleteMemoryEntity(id);
-    } catch {
-      // Entity may already be deleted
-    }
-  }
-});
-
-describeIfMigrated("Memory Tier System (integration)", () => {
-  test("create entity with explicit tier", async () => {
-    const client = getClient();
-    const workspaceId = getActiveWorkspaceId()!;
-    const projectId = getActiveProjectId() || undefined;
-
-    const result = await client.createMemoryEntity({
-      workspace_id: workspaceId,
-      project_id: projectId,
-      type: "context",
-      scope: projectId ? "project" : "workspace",
-      memory_tier: "draft",
-      title: "[TEST] Draft memory tier test",
-      content: "This is a test draft memory.",
-      tags: ["test", "integration"],
-      agent_identifier: "test-runner",
-    });
-
-    const entity = result.entity as Record<string, unknown>;
-    expect(entity.id).toBeTruthy();
-    expect(entity.memory_tier).toBe("draft");
-    createdEntityIds.push(entity.id as string);
-  });
-
-  test("create entity with default tier based on type", async () => {
-    const client = getClient();
-    const workspaceId = getActiveWorkspaceId()!;
-    const projectId = getActiveProjectId() || undefined;
-
-    // 'lesson' type should default to 'episode' tier
-    const result = await client.createMemoryEntity({
-      workspace_id: workspaceId,
-      project_id: projectId,
-      type: "lesson",
-      scope: projectId ? "project" : "workspace",
-      title: "[TEST] Lesson tier default",
-      content: "Testing that lessons default to episode tier.",
-      tags: ["test", "integration"],
-      agent_identifier: "test-runner",
-    });
-
-    const entity = result.entity as Record<string, unknown>;
-    expect(entity.id).toBeTruthy();
-    expect(entity.memory_tier).toBe("episode");
-    createdEntityIds.push(entity.id as string);
-  });
-
-  test("create pattern defaults to reference tier", async () => {
-    const client = getClient();
-    const workspaceId = getActiveWorkspaceId()!;
-    const projectId = getActiveProjectId() || undefined;
-
-    const result = await client.createMemoryEntity({
-      workspace_id: workspaceId,
-      project_id: projectId,
-      type: "pattern",
-      scope: projectId ? "project" : "workspace",
-      title: "[TEST] Pattern tier default",
-      content: "Testing that patterns default to reference tier.",
-      tags: ["test", "integration"],
-      agent_identifier: "test-runner",
-    });
-
-    const entity = result.entity as Record<string, unknown>;
-    expect(entity.memory_tier).toBe("reference");
-    createdEntityIds.push(entity.id as string);
-  });
-
-  test("update entity tier via promote", async () => {
-    const client = getClient();
-    const workspaceId = getActiveWorkspaceId()!;
-    const projectId = getActiveProjectId() || undefined;
-
-    // Create a draft
-    const createResult = await client.createMemoryEntity({
-      workspace_id: workspaceId,
-      project_id: projectId,
-      type: "context",
-      scope: projectId ? "project" : "workspace",
-      memory_tier: "draft",
-      title: "[TEST] Promotion test draft",
-      content: "Draft that will be promoted.",
-      tags: ["test", "integration"],
-      agent_identifier: "test-runner",
-    });
-
-    const entityId = (createResult.entity as Record<string, unknown>)
-      .id as string;
-    createdEntityIds.push(entityId);
-
-    // Promote to episode
-    const updateResult = await client.updateMemoryEntity(entityId, {
-      memory_tier: "episode",
-      metadata: {
-        promoted_from_tier: "draft",
-        promotion_reason: "test promotion",
-        promoted_at: new Date().toISOString(),
-      },
-    });
-
-    const updated = updateResult.entity as Record<string, unknown>;
-    expect(updated.memory_tier).toBe("episode");
-  });
-});
-
-describeIf("Context Assembly (integration)", () => {
-  test("search returns entities with tier info", async () => {
-    const client = getClient();
-    const workspaceId = getActiveWorkspaceId()!;
-    const projectId = getActiveProjectId() || undefined;
-
-    // Create a searchable entity
-    const createResult = await client.createMemoryEntity({
-      workspace_id: workspaceId,
-      project_id: projectId,
-      type: "solution",
-      scope: projectId ? "project" : "workspace",
-      memory_tier: "reference",
-      title: "[TEST] Unique search term xyzzy42",
-      content: "A solution for testing context assembly search.",
-      confidence: 0.95,
-      tags: ["test", "context-assembly"],
-      agent_identifier: "test-runner",
-    });
-
-    const entityId = (createResult.entity as Record<string, unknown>)
-      .id as string;
-    createdEntityIds.push(entityId);
-
-    // Search for it
-    const searchResult = await client.searchMemoryEntities(
-      workspaceId,
-      "xyzzy42",
-      { project_id: projectId, limit: 5 },
-    );
-
-    expect(searchResult.entities.length).toBeGreaterThan(0);
-    const found = searchResult.entities.find(
-      (e: unknown) => (e as Record<string, unknown>).id === entityId,
-    );
-    expect(found).toBeTruthy();
-    expect((found as Record<string, unknown>).memory_tier).toBe("reference");
-  });
-});
-
-describeIf("Graph Walk (integration)", () => {
-  test("create entities with relations and traverse", async () => {
-    const client = getClient();
-    const workspaceId = getActiveWorkspaceId()!;
-    const projectId = getActiveProjectId() || undefined;
-    const scope = projectId ? "project" : "workspace";
-
-    // Create two related entities
-    const errorResult = await client.createMemoryEntity({
-      workspace_id: workspaceId,
-      project_id: projectId,
-      type: "error",
-      scope,
-      memory_tier: "reference",
-      title: "[TEST] Graph walk error",
-      content: "An error for graph walk testing.",
-      tags: ["test", "graph-walk"],
-      agent_identifier: "test-runner",
-    });
-    const errorId = (errorResult.entity as Record<string, unknown>)
-      .id as string;
-    createdEntityIds.push(errorId);
-
-    const solutionResult = await client.createMemoryEntity({
-      workspace_id: workspaceId,
-      project_id: projectId,
-      type: "solution",
-      scope,
-      memory_tier: "reference",
-      title: "[TEST] Graph walk solution",
-      content: "A solution for graph walk testing.",
-      tags: ["test", "graph-walk"],
-      agent_identifier: "test-runner",
-    });
-    const solutionId = (solutionResult.entity as Record<string, unknown>)
-      .id as string;
-    createdEntityIds.push(solutionId);
-
-    // Create relation
-    const relResult = await client.createMemoryRelation({
-      source_id: errorId,
-      target_id: solutionId,
-      relation_type: "resolved_by",
-      confidence: 1.0,
-    });
-    expect((relResult.relation as Record<string, unknown>).id).toBeTruthy();
-
-    // Verify relations via getRelatedEntities
-    const related = await client.getRelatedEntities(errorId);
-    expect(related.outgoing.length).toBeGreaterThan(0);
-
-    // API returns relations with embedded target entity, not flat target_id
-    const outRel = related.outgoing.find((r: unknown) => {
-      const rel = r as Record<string, unknown>;
-      const target = rel.target as Record<string, unknown> | undefined;
-      return target?.id === solutionId || rel.target_id === solutionId;
-    });
-    expect(outRel).toBeTruthy();
-  });
-});
-
-describeIf("Vault Index with Tiers (integration)", () => {
-  test("vault index includes tier information", async () => {
-    const client = getClient();
-    const workspaceId = getActiveWorkspaceId()!;
-    const projectId = getActiveProjectId() || undefined;
-
-    let result: { entities: unknown[]; count: number };
-    try {
-      result = await client.getVaultIndex({
-        workspace_id: workspaceId,
-        project_id: projectId,
-        limit: 10,
-      });
-    } catch (e) {
-      // Endpoint may not be deployed yet - skip gracefully
-      const msg = e instanceof Error ? e.message : String(e);
-      if (msg.includes("Unknown endpoint")) {
-        console.log("Skipping: vault index endpoint not deployed yet");
-        return;
-      }
-      throw e;
-    }
-
-    expect(result.entities).toBeDefined();
-    // If there are entities, check they have tier info
-    if (result.entities.length > 0) {
-      const first = result.entities[0] as Record<string, unknown>;
-      // memory_tier might be present if migration is applied
-      if (first.memory_tier !== undefined) {
-        expect(["draft", "episode", "reference"]).toContain(first.memory_tier);
-      }
-    }
-  });
-});

package/src/__tests__/lifecycle-maintenance.test.ts

@@ -1,238 +0,0 @@
-/**
- * Unit tests for automatic lifecycle maintenance.
- *
- * Run with: bun test packages/mcp-server/src/__tests__/lifecycle-maintenance.test.ts
- */
-
-import { describe, expect, mock, test } from "bun:test";
-import { runLifecycleMaintenance } from "../lifecycle-maintenance.js";
-
-function daysAgo(days: number): string {
-  return new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
-}
-
-function makeMockClient(entities: unknown[]) {
-  const deletedIds: string[] = [];
-  const updatedEntities: Array<{
-    id: string;
-    updates: Record<string, unknown>;
-  }> = [];
-
-  return {
-    client: {
-      listMemoryEntities: mock(async () => ({
-        entities,
-        count: entities.length,
-      })),
-      deleteMemoryEntity: mock(async (id: string) => {
-        deletedIds.push(id);
-        return { success: true };
-      }),
-      updateMemoryEntity: mock(
-        async (id: string, updates: Record<string, unknown>) => {
-          updatedEntities.push({ id, updates });
-          return { entity: { id, ...updates } };
-        },
-      ),
-    } as any,
-    deletedIds,
-    updatedEntities,
-  };
-}
-
-describe("runLifecycleMaintenance", () => {
-  test("archives low-confidence entities", async () => {
-    const { client, deletedIds } = makeMockClient([
-      {
-        id: "low-conf-1",
-        title: "Bad memory",
-        memory_tier: "draft",
-        confidence: 0.1,
-        access_count: 0,
-        last_accessed_at: daysAgo(5),
-        created_at: daysAgo(10),
-      },
-    ]);
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.archived).toBe(1);
-    expect(deletedIds).toContain("low-conf-1");
-  });
-
-  test("prunes stale drafts older than 30 days with low decay", async () => {
-    const { client, deletedIds } = makeMockClient([
-      {
-        id: "stale-draft-1",
-        title: "Old draft",
-        memory_tier: "draft",
-        confidence: 0.5,
-        access_count: 0,
-        last_accessed_at: daysAgo(35),
-        created_at: daysAgo(35),
-      },
-    ]);
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.pruned).toBe(1);
-    expect(deletedIds).toContain("stale-draft-1");
-  });
-
-  test("does NOT prune recent drafts", async () => {
-    const { client, deletedIds } = makeMockClient([
-      {
-        id: "fresh-draft",
-        title: "New draft",
-        memory_tier: "draft",
-        confidence: 0.5,
-        access_count: 1,
-        last_accessed_at: daysAgo(2),
-        created_at: daysAgo(5),
-      },
-    ]);
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.pruned).toBe(0);
-    expect(result.archived).toBe(0);
-    expect(deletedIds).toHaveLength(0);
-  });
-
-  test("auto-promotes eligible draft to episode", async () => {
-    const { client, updatedEntities } = makeMockClient([
-      {
-        id: "promote-me",
-        title: "Well-used draft",
-        memory_tier: "draft",
-        confidence: 0.85,
-        access_count: 6,
-        last_accessed_at: daysAgo(0),
-        created_at: daysAgo(3),
-      },
-    ]);
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.promoted).toBe(1);
-    expect(updatedEntities[0].id).toBe("promote-me");
-    expect(updatedEntities[0].updates.memory_tier).toBe("episode");
-  });
-
-  test("auto-promotes eligible episode to reference", async () => {
-    const { client, updatedEntities } = makeMockClient([
-      {
-        id: "promote-ep",
-        title: "Proven episode",
-        memory_tier: "episode",
-        confidence: 0.95,
-        access_count: 12,
-        last_accessed_at: daysAgo(1),
-        created_at: daysAgo(10),
-      },
-    ]);
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.promoted).toBe(1);
-    expect(updatedEntities[0].updates.memory_tier).toBe("reference");
-  });
-
-  test("flags stale entities for review", async () => {
-    const { client, updatedEntities } = makeMockClient([
-      {
-        id: "stale-ep",
-        title: "Forgotten episode",
-        memory_tier: "episode",
-        confidence: 0.6,
-        access_count: 2,
-        last_accessed_at: daysAgo(100),
-        created_at: daysAgo(120),
-      },
-    ]);
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.reviewed).toBe(1);
-    expect(updatedEntities[0].id).toBe("stale-ep");
-    expect(updatedEntities[0].updates.metadata).toHaveProperty(
-      "needs_review",
-      true,
-    );
-  });
-
-  test("does not flag frequently accessed stale entities", async () => {
-    const { client, updatedEntities } = makeMockClient([
-      {
-        id: "old-but-used",
-        title: "Still relevant",
-        memory_tier: "episode",
-        confidence: 0.7,
-        access_count: 10,
-        last_accessed_at: daysAgo(100),
-        created_at: daysAgo(120),
-      },
-    ]);
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.reviewed).toBe(0);
-    expect(updatedEntities).toHaveLength(0);
-  });
-
-  test("handles empty entity list", async () => {
-    const { client } = makeMockClient([]);
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.archived).toBe(0);
-    expect(result.pruned).toBe(0);
-    expect(result.promoted).toBe(0);
-    expect(result.reviewed).toBe(0);
-  });
-
-  test("handles API errors gracefully", async () => {
-    const client = {
-      listMemoryEntities: mock(async () => {
-        throw new Error("API down");
-      }),
-    } as any;
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.errors).toBe(0); // Early return, no entity-level errors
-    expect(result.archived).toBe(0);
-  });
-
-  test("processes mixed entities correctly", async () => {
-    const { client, deletedIds, updatedEntities } = makeMockClient([
-      // Should be archived (low confidence)
-      {
-        id: "archive-me",
-        title: "Low conf",
-        memory_tier: "draft",
-        confidence: 0.2,
-        access_count: 1,
-        last_accessed_at: daysAgo(5),
-        created_at: daysAgo(10),
-      },
-      // Should be promoted (draft→episode)
-      {
-        id: "promote-me",
-        title: "Good draft",
-        memory_tier: "draft",
-        confidence: 0.85,
-        access_count: 7,
-        last_accessed_at: daysAgo(0),
-        created_at: daysAgo(5),
-      },
-      // Should be left alone (healthy reference)
-      {
-        id: "leave-me",
-        title: "Healthy ref",
-        memory_tier: "reference",
-        confidence: 0.95,
-        access_count: 20,
-        last_accessed_at: daysAgo(1),
-        created_at: daysAgo(60),
-      },
-    ]);
-
-    const result = await runLifecycleMaintenance(client, "ws-1");
-    expect(result.archived).toBe(1);
-    expect(result.promoted).toBe(1);
-    expect(deletedIds).toContain("archive-me");
-    expect(updatedEntities[0].id).toBe("promote-me");
-    expect(updatedEntities[0].updates.memory_tier).toBe("episode");
-  });
-});