@gethmy/mcp 2.0.0 → 2.1.1

package/dist/index.js

@@ -22942,7 +22942,7 @@ function hasLocalConfig(cwd) {
 function getApiKey() {
   const config2 = loadConfig();
   if (!config2.apiKey) {
-    throw new Error(`Not configured. Run "harmony-mcp configure" to set your API key.
+    throw new Error(`Not configured. Run "npx @gethmy/mcp setup" to set your API key.
 ` + "You can generate an API key at https://gethmy.com → Settings → API Keys.");
   }
   return config2.apiKey;
@@ -24061,6 +24061,8 @@ class HarmonyApiClient {
       params.set("summary", "true");
     if (options?.includeArchived)
       params.set("include_archived", "true");
+    if (options?.labelName)
+      params.set("label_name", options.labelName);
     const query = params.toString() ? `?${params.toString()}` : "";
     return this.request("GET", `/board/${projectId}${query}`);
   }
@@ -27169,7 +27171,7 @@ function registerHandlers(server, deps) {
 async function handleToolCall(name, args, deps) {
   const unauthenticatedTools = ["harmony_signup", "harmony_onboard"];
   if (!unauthenticatedTools.includes(name) && !deps.isConfigured()) {
-    throw new Error(`Not configured. Run "harmony-mcp configure" to set your API key.
+    throw new Error(`Not configured. Run "npx @gethmy/mcp setup" to set your API key.
 ` + `You can generate an API key at https://gethmy.com → Settings → API Keys.
 ` + 'Or use "harmony_onboard" to create an account and configure automatically.');
   }
@@ -28464,7 +28466,7 @@ function createConfigDeps() {
 class HarmonyMCPServer {
   server;
   constructor() {
-    this.server = new Server({ name: "harmony-mcp", version: "1.0.0" }, { capabilities: { tools: {}, resources: {} } });
+    this.server = new Server({ name: "@gethmy/mcp", version: "2.0.0" }, { capabilities: { tools: {}, resources: {} } });
     registerHandlers(this.server, createConfigDeps());
   }
   async run() {

package/dist/lib/__tests__/active-learning.test.js

@@ -0,0 +1,386 @@
+/**
+ * Unit tests for the Active Learning system.
+ *
+ * These tests use a mock API client to verify extraction rules
+ * and confidence-based routing - no real API calls.
+ *
+ * Run with: bun test packages/mcp-server/src/__tests__/active-learning.test.ts
+ */
+import { describe, expect, mock, test } from "bun:test";
+// Mock the config module before importing active-learning
+let mockWorkspaceId = "ws-test-123";
+const mockProjectId = "proj-test-456";
+mock.module("../config.js", () => ({
+    getActiveWorkspaceId: () => mockWorkspaceId,
+    getActiveProjectId: () => mockProjectId,
+    isConfigured: () => true,
+    loadConfig: () => { },
+}));
+// Import after mocking
+const { extractLearnings } = await import("../active-learning.js");
+// Extended mock client that satisfies all methods called by fire-and-forget paths
+// (autoExpandGraph, detectAndCreatePatterns). Unused by most tests but prevents crashes.
+function makeFullMockClient() {
+    const createdEntities = [];
+    let nextId = 1;
+    return {
+        createdEntities,
+        createMemoryEntity: mock(async (data) => {
+            const entity = { id: `entity-${nextId++}`, ...data };
+            createdEntities.push(entity);
+            return { entity };
+        }),
+        updateMemoryEntity: mock(async (entityId, updates) => ({
+            entity: { id: entityId, ...updates },
+        })),
+        deleteMemoryEntity: mock(async () => ({ success: true })),
+        listMemoryEntities: mock(async () => ({
+            entities: [],
+            count: 0,
+        })),
+        getMemoryEntity: mock(async (id) => ({
+            entity: { id, type: "lesson" },
+        })),
+        searchMemoryEntities: mock(async () => ({
+            entities: [],
+            count: 0,
+        })),
+        createMemoryRelation: mock(async () => ({ relation: {} })),
+    };
+}
+// ---- Mock helpers ----
+function makeMockClient() {
+    const createdEntities = [];
+    let nextId = 1;
+    return {
+        createdEntities,
+        createMemoryEntity: mock(async (data) => {
+            const entity = { id: `entity-${nextId++}`, ...data };
+            createdEntities.push(entity);
+            return { entity };
+        }),
+        updateMemoryEntity: mock(async (entityId, updates) => {
+            return { entity: { id: entityId, ...updates } };
+        }),
+        deleteMemoryEntity: mock(async () => ({ success: true })),
+        listMemoryEntities: mock(async () => ({
+            entities: [],
+            count: 0,
+        })),
+    };
+}
+function makeSession(overrides = {}) {
+    return {
+        cardId: "card-1",
+        cardTitle: "Fix login bug",
+        cardLabels: ["feature"],
+        agentIdentifier: "claude-code",
+        agentName: "Claude Code",
+        status: "completed",
+        progressPercent: 100,
+        ...overrides,
+    };
+}
+// ---- Tests ----
+describe("extractLearnings", () => {
+    describe("Rule 1: Blockers create error entities", () => {
+        test("session with blockers creates error entities", async () => {
+            const client = makeMockClient();
+            const session = makeSession({
+                blockers: ["API rate limit exceeded", "Database timeout"],
+                status: "completed",
+            });
+            const result = await extractLearnings(client, session);
+            // 2 blockers + 1 session lesson = 3 entities
+            expect(result.count).toBe(3);
+            expect(result.entityIds).toHaveLength(3);
+            // Check error entities were created for each blocker
+            const errorEntities = client.createdEntities.filter((e) => e.type === "error");
+            expect(errorEntities).toHaveLength(2);
+            expect(errorEntities[0].title).toContain("Blocker:");
+            expect(errorEntities[0].title).toContain("API rate limit");
+            expect(errorEntities[0].memory_tier).toBe("reference");
+            expect(errorEntities[0].confidence).toBe(0.7);
+            expect(errorEntities[0].tags ?? []).toContain("auto-extracted");
+            expect(errorEntities[0].tags ?? []).toContain("blocker");
+        });
+        test("blocker title is truncated to 100 chars", async () => {
+            const client = makeMockClient();
+            const longBlocker = "A".repeat(200);
+            const session = makeSession({
+                blockers: [longBlocker],
+                status: "paused",
+            });
+            await extractLearnings(client, session);
+            const errorEntities = client.createdEntities.filter((e) => e.type === "error");
+            expect(errorEntities).toHaveLength(1);
+            // Title: "Blocker: " + 100 chars
+            expect(errorEntities[0].title.length).toBeLessThanOrEqual(110);
+        });
+    });
+    describe("Rule 2: Completed sessions create lesson entities", () => {
+        test("clean completed session does NOT create lesson entity", async () => {
+            const client = makeMockClient();
+            const session = makeSession({
+                status: "completed",
+                currentTask: "Deployed to production",
+                progressPercent: 100,
+                sessionDurationMs: 300000, // 5 minutes
+            });
+            const result = await extractLearnings(client, session);
+            expect(result.count).toBe(0);
+            const lessons = client.createdEntities.filter((e) => e.type === "lesson");
+            expect(lessons).toHaveLength(0);
+        });
+        test("completed session with blockers creates lesson entity", async () => {
+            const client = makeMockClient();
+            const session = makeSession({
+                status: "completed",
+                currentTask: "Deployed to production",
+                progressPercent: 100,
+                sessionDurationMs: 300000, // 5 minutes
+                blockers: ["API rate limit hit"],
+            });
+            const _result = await extractLearnings(client, session);
+            // 1 error entity (Rule 1) + 1 lesson entity (Rule 2)
+            const lesson = client.createdEntities.find((e) => e.type === "lesson");
+            expect(lesson).toBeTruthy();
+            expect(lesson.title).toContain("Session:");
+            expect(lesson.memory_tier).toBe("episode");
+            expect(lesson.confidence).toBe(0.7);
+            expect(lesson.content).toContain("Deployed to production");
+            expect(lesson.content).toContain("5 minutes");
+        });
+        test("completed session with incomplete subtasks creates lesson entity", async () => {
+            const client = makeMockClient();
+            const session = makeSession({
+                status: "completed",
+                currentTask: "Finished main work",
+                progressPercent: 100,
+                cardSubtasks: [
+                    { title: "Step 1", done: true },
+                    { title: "Step 2", done: false },
+                ],
+            });
+            const _result = await extractLearnings(client, session);
+            const lesson = client.createdEntities.find((e) => e.type === "lesson");
+            expect(lesson).toBeTruthy();
+            expect(lesson.title).toContain("Session:");
+        });
+        test("paused session does NOT create lesson entity", async () => {
+            const client = makeMockClient();
+            const session = makeSession({ status: "paused", blockers: undefined });
+            const result = await extractLearnings(client, session);
+            expect(result.count).toBe(0);
+            const lessons = client.createdEntities.filter((e) => e.type === "lesson");
+            expect(lessons).toHaveLength(0);
+        });
+    });
+    describe("Rule 3: Bug label + completed creates solution entity", () => {
+        test('card with "bug" label creates solution entity', async () => {
+            const client = makeMockClient();
+            const session = makeSession({
+                cardLabels: ["bug", "priority-high"],
+                status: "completed",
+            });
+            const _result = await extractLearnings(client, session);
+            const solutions = client.createdEntities.filter((e) => e.type === "solution");
+            expect(solutions).toHaveLength(1);
+            expect(solutions[0].title).toContain("Solution:");
+            expect(solutions[0].memory_tier).toBe("reference");
+            expect(solutions[0].confidence).toBe(0.8);
+            expect(solutions[0].tags ?? []).toContain("bug-fix");
+        });
+        test('case-insensitive "Bug" label works', async () => {
+            const client = makeMockClient();
+            const session = makeSession({
+                cardLabels: ["Bug"],
+                status: "completed",
+            });
+            await extractLearnings(client, session);
+            const solutions = client.createdEntities.filter((e) => e.type === "solution");
+            // The check is .toLowerCase(), so "Bug" matches
+            expect(solutions).toHaveLength(1);
+        });
+        test("bug label + paused does NOT create solution", async () => {
+            const client = makeMockClient();
+            const session = makeSession({
+                cardLabels: ["bug"],
+                status: "paused",
+            });
+            await extractLearnings(client, session);
+            const solutions = client.createdEntities.filter((e) => e.type === "solution");
+            expect(solutions).toHaveLength(0);
+        });
+        for (const label of ["fix", "hotfix", "defect", "error"]) {
+            test(`"${label}" label also triggers solution creation`, async () => {
+                const client = makeMockClient();
+                const session = makeSession({
+                    cardLabels: [label],
+                    status: "completed",
+                });
+                await extractLearnings(client, session);
+                const solutions = client.createdEntities.filter((e) => e.type === "solution");
+                expect(solutions).toHaveLength(1);
+            });
+        }
+    });
+    describe("Card labels are included in tags", () => {
+        test("first 3 card labels are appended to tags", async () => {
+            const client = makeMockClient();
+            const session = makeSession({
+                cardLabels: ["feature", "frontend", "urgent", "extra"],
+                status: "completed",
+                blockers: ["test blocker"],
+            });
+            await extractLearnings(client, session);
+            const lesson = client.createdEntities.find((e) => e.type === "lesson");
+            const tags = lesson.tags;
+            expect(tags).toContain("feature");
+            expect(tags).toContain("frontend");
+            expect(tags).toContain("urgent");
+            expect(tags).not.toContain("extra"); // Only first 3
+        });
+    });
+    describe("Error handling", () => {
+        test("individual entity creation failure does not break others", async () => {
+            let callCount = 0;
+            const client = {
+                createMemoryEntity: mock(async (_data) => {
+                    callCount++;
+                    if (callCount === 1)
+                        throw new Error("Network error");
+                    return { entity: { id: `entity-${callCount}` } };
+                }),
+            };
+            const session = makeSession({
+                blockers: ["blocker-1"],
+                status: "completed",
+            });
+            // blocker creates error (fails), completed creates lesson (succeeds)
+            const result = await extractLearnings(client, session);
+            // Only 1 succeeded out of 2
+            expect(result.entityIds).toHaveLength(1);
+            expect(result.count).toBe(1);
+        });
+    });
+    describe("No workspace returns empty", () => {
+        test("returns empty when no workspace configured", async () => {
+            // Temporarily override
+            const origWs = mockWorkspaceId;
+            mockWorkspaceId = null;
+            const client = makeMockClient();
+            const session = makeSession();
+            const result = await extractLearnings(client, session);
+            expect(result.count).toBe(0);
+            expect(result.entityIds).toHaveLength(0);
+            // Restore
+            mockWorkspaceId = origWs;
+        });
+    });
+});
+describe("extractLearnings - entity metadata", () => {
+    test("stores card_id and source in metadata", async () => {
+        const client = makeMockClient();
+        const session = makeSession({
+            cardId: "card-abc",
+            status: "completed",
+            blockers: ["test blocker"],
+        });
+        await extractLearnings(client, session);
+        const lesson = client.createdEntities.find((e) => e.type === "lesson");
+        const meta = lesson.metadata;
+        expect(meta.source).toBe("active_learning");
+        expect(meta.card_id).toBe("card-abc");
+    });
+    test("lesson entity carries agent_identifier", async () => {
+        const client = makeMockClient();
+        const session = makeSession({
+            agentIdentifier: "my-agent-v2",
+            status: "completed",
+            blockers: ["test blocker"],
+        });
+        await extractLearnings(client, session);
+        const lesson = client.createdEntities.find((e) => e.type === "lesson");
+        expect(lesson.agent_identifier).toBe("my-agent-v2");
+    });
+    test("session lesson content includes agent name", async () => {
+        const client = makeMockClient();
+        const session = makeSession({
+            agentName: "TestBot",
+            status: "completed",
+            blockers: ["test blocker"],
+        });
+        await extractLearnings(client, session);
+        const lesson = client.createdEntities.find((e) => e.type === "lesson");
+        expect(lesson.content).toContain("TestBot");
+    });
+    test("clean completed session without meaningful content skips lesson", async () => {
+        const client = makeMockClient();
+        const session = makeSession({
+            status: "completed",
+            currentTask: undefined,
+            progressPercent: undefined,
+            sessionDurationMs: undefined,
+            blockers: undefined,
+        });
+        const result = await extractLearnings(client, session);
+        expect(result.count).toBe(0);
+        const lessons = client.createdEntities.filter((e) => e.type === "lesson");
+        expect(lessons).toHaveLength(0);
+    });
+});
+describe("extractLearnings - returns correct entityIds", () => {
+    test("entityIds array matches returned count", async () => {
+        const client = makeMockClient();
+        const session = makeSession({
+            cardLabels: ["bug"],
+            blockers: ["error occurred"],
+            status: "completed",
+        });
+        const result = await extractLearnings(client, session);
+        // error + lesson + solution = 3
+        expect(result.count).toBe(result.entityIds.length);
+        expect(result.entityIds).toHaveLength(3);
+        // All IDs should be truthy strings
+        for (const id of result.entityIds) {
+            expect(typeof id).toBe("string");
+            expect(id.length).toBeGreaterThan(0);
+        }
+    });
+    test("entityIds are unique", async () => {
+        const client = makeMockClient();
+        const session = makeSession({
+            cardLabels: ["bug"],
+            blockers: ["err-1", "err-2"],
+            status: "completed",
+        });
+        const result = await extractLearnings(client, session);
+        const unique = new Set(result.entityIds);
+        expect(unique.size).toBe(result.entityIds.length);
+    });
+});
+describe("extractLearnings - fire-and-forget calls don't crash", () => {
+    test("works with full client (autoExpandGraph and detectAndCreatePatterns paths)", async () => {
+        const client = makeFullMockClient();
+        const session = makeSession({ status: "completed", blockers: ["test"] });
+        // Should not throw even when graph expansion / pattern detection run
+        const result = await extractLearnings(client, session);
+        expect(result.count).toBeGreaterThan(0);
+        // Flush microtasks so fire-and-forget paths complete
+        await new Promise((r) => setTimeout(r, 10));
+        // searchMemoryEntities was called by autoExpandGraph
+        expect(client.searchMemoryEntities).toHaveBeenCalled();
+    });
+    test("client errors in fire-and-forget paths do not surface to caller", async () => {
+        const client = makeFullMockClient();
+        // Make the search throw - should be swallowed
+        client.searchMemoryEntities = mock(async () => {
+            throw new Error("Search service unavailable");
+        });
+        const session = makeSession({ status: "completed", blockers: ["test"] });
+        const result = await extractLearnings(client, session);
+        // Main extraction still succeeded (error + lesson)
+        expect(result.count).toBe(2);
+    });
+});