@gethmy/mcp 2.3.1 → 2.3.3

package/dist/lib/__tests__/integration-memory-system.test.js

@@ -1,281 +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 = [];
-// 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;
-        const hasTier = entity.memory_tier === "draft";
-        // Clean up probe entity
-        if (entity.id) {
-            await client.deleteMemoryEntity(entity.id).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;
-        expect(entity.id).toBeTruthy();
-        expect(entity.memory_tier).toBe("draft");
-        createdEntityIds.push(entity.id);
-    });
-    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;
-        expect(entity.id).toBeTruthy();
-        expect(entity.memory_tier).toBe("episode");
-        createdEntityIds.push(entity.id);
-    });
-    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;
-        expect(entity.memory_tier).toBe("reference");
-        createdEntityIds.push(entity.id);
-    });
-    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
-            .id;
-        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;
-        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
-            .id;
-        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) => e.id === entityId);
-        expect(found).toBeTruthy();
-        expect(found.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
-            .id;
-        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
-            .id;
-        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.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) => {
-            const rel = r;
-            const target = rel.target;
-            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;
-        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];
-            // memory_tier might be present if migration is applied
-            if (first.memory_tier !== undefined) {
-                expect(["draft", "episode", "reference"]).toContain(first.memory_tier);
-            }
-        }
-    });
-});

package/dist/lib/__tests__/lifecycle-maintenance.test.js

@@ -1,207 +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) {
-    return new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
-}
-function makeMockClient(entities) {
-    const deletedIds = [];
-    const updatedEntities = [];
-    return {
-        client: {
-            listMemoryEntities: mock(async () => ({
-                entities,
-                count: entities.length,
-            })),
-            deleteMemoryEntity: mock(async (id) => {
-                deletedIds.push(id);
-                return { success: true };
-            }),
-            updateMemoryEntity: mock(async (id, updates) => {
-                updatedEntities.push({ id, updates });
-                return { entity: { id, ...updates } };
-            }),
-        },
-        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");
-            }),
-        };
-        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");
-    });
-});