@gethmy/mcp 2.4.6 → 2.5.0

package/dist/lib/config.js

@@ -1,11 +1,15 @@
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/mcp",
-  "version": "2.4.6",
+  "version": "2.5.0",
   "description": "MCP server for Harmony Kanban board - enables AI coding agents to manage your boards",
   "publishConfig": {
     "access": "public"
@@ -59,7 +59,7 @@
     "serve:remote": "bun src/remote.ts",
     "dev": "bun --watch src/index.ts",
     "test": "bun run test:unit && bun run test:integration",
-    "test:unit": "bun test src/__tests__/active-learning.test.ts src/__tests__/context-assembly.test.ts src/__tests__/prompt-builder.test.ts src/__tests__/memory-audit.test.ts",
+    "test:unit": "bun test src/__tests__/active-learning.test.ts src/__tests__/context-assembly.test.ts src/__tests__/prompt-builder.test.ts src/__tests__/memory-audit.test.ts src/__tests__/skills.test.ts src/__tests__/tool-dispatch.test.ts src/__tests__/mcp-integration.test.ts",
     "test:integration": "bun test src/__tests__/integration-memory-system.test.ts src/__tests__/integration-memory-crud.test.ts",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run build"

package/src/__tests__/mcp-integration.test.ts

@@ -0,0 +1,141 @@
+/**
+ * In-process MCP integration smoke. Card #182.
+ *
+ * Wires a real Server through `registerHandlers` and a real Client over an
+ * InMemoryTransport pair. Asserts JSON-RPC wire format end-to-end:
+ *
+ *   - listTools returns every TOOLS row.
+ *   - callTool dispatches and returns content.
+ *   - listResources / readResource roundtrip.
+ *   - unknown tool name surfaces as MCP-level error.
+ *
+ * This is the only place we exercise the SDK's transport + JSON-RPC layer.
+ * The dispatch unit tests in tool-dispatch.test.ts cover handler logic with
+ * a fake Server; this file confirms nothing breaks at the wire boundary.
+ *
+ * Run with: bun test packages/mcp-server/src/__tests__/mcp-integration.test.ts
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+
+import {
+  RESOURCES,
+  registerHandlers,
+  TOOLS,
+  type ToolDeps,
+} from "../server.js";
+
+const TOOL_COUNT = Object.keys(TOOLS).length;
+
+function makeDeps(): ToolDeps {
+  return {
+    getClient: () => ({}) as never,
+    isConfigured: () => true,
+    getActiveProjectId: () => "11111111-1111-1111-1111-111111111111",
+    getActiveWorkspaceId: () => "22222222-2222-2222-2222-222222222222",
+    setActiveProject: () => {},
+    setActiveWorkspace: () => {},
+    getApiUrl: () => "http://localhost",
+    getMemoryDir: () => null,
+    getUserEmail: () => null,
+    saveConfig: () => {},
+    resetClient: () => {},
+  };
+}
+
+describe("MCP integration — in-process Client ↔ Server", () => {
+  let client: Client;
+  let server: Server;
+
+  beforeAll(async () => {
+    const [clientTransport, serverTransport] =
+      InMemoryTransport.createLinkedPair();
+
+    server = new Server(
+      { name: "harmony-test", version: "0.0.0" },
+      { capabilities: { tools: {}, resources: {} } },
+    );
+    registerHandlers(server, makeDeps());
+    await server.connect(serverTransport);
+
+    client = new Client(
+      { name: "harmony-test-client", version: "0.0.0" },
+      { capabilities: {} },
+    );
+    await client.connect(clientTransport);
+  });
+
+  afterAll(async () => {
+    await client.close();
+    await server.close();
+  });
+
+  test("listTools delivers every registered tool", async () => {
+    const result = await client.listTools();
+    expect(result.tools.length).toBe(TOOL_COUNT);
+    for (const tool of result.tools) {
+      expect(typeof tool.name).toBe("string");
+      expect(typeof tool.description).toBe("string");
+      expect(tool.inputSchema).toMatchObject({ type: "object" });
+    }
+  });
+
+  test("callTool routes harmony_get_context end-to-end", async () => {
+    const result = await client.callTool({
+      name: "harmony_get_context",
+      arguments: {},
+    });
+
+    expect(result.isError).toBeUndefined();
+    const content = result.content as Array<{ type: string; text: string }>;
+    expect(content[0].type).toBe("text");
+    const payload = JSON.parse(content[0].text);
+    expect(payload.success).toBe(true);
+    expect(payload.context.activeWorkspaceId).toBe(
+      "22222222-2222-2222-2222-222222222222",
+    );
+    expect(payload.context.activeProjectId).toBe(
+      "11111111-1111-1111-1111-111111111111",
+    );
+  });
+
+  test("callTool with unknown name returns isError content", async () => {
+    const result = await client.callTool({
+      name: "harmony_does_not_exist",
+      arguments: {},
+    });
+    expect(result.isError).toBe(true);
+    const content = result.content as Array<{ type: string; text: string }>;
+    expect(content[0].text.toLowerCase()).toContain("error");
+  });
+
+  test("listResources delivers RESOURCES", async () => {
+    const result = await client.listResources();
+    expect(result.resources.length).toBe(RESOURCES.length);
+    expect(result.resources[0].uri).toBe(RESOURCES[0].uri);
+  });
+
+  test("readResource serves harmony://context", async () => {
+    const result = await client.readResource({ uri: "harmony://context" });
+    const contents = result.contents as Array<{
+      uri: string;
+      mimeType?: string;
+      text?: string;
+    }>;
+    expect(contents[0].uri).toBe("harmony://context");
+    expect(contents[0].mimeType).toBe("application/json");
+    const parsed = JSON.parse(contents[0].text ?? "{}");
+    expect(parsed).toHaveProperty("configured");
+    expect(parsed).toHaveProperty("activeWorkspaceId");
+    expect(parsed).toHaveProperty("activeProjectId");
+  });
+
+  test("readResource on unknown URI surfaces JSON-RPC error", async () => {
+    await expect(
+      client.readResource({ uri: "harmony://unknown" }),
+    ).rejects.toThrow(/Unknown resource/);
+  });
+});

package/src/__tests__/memory-floor.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "bun:test";
+import { validateMemoryQuality } from "../memory-floor.js";
+
+const ok = (
+  overrides: Partial<Parameters<typeof validateMemoryQuality>[0]> = {},
+) => ({
+  title: "AnnotatedTextarea auto-grow deps must include open state",
+  content:
+    "When the parent prop changes from closed to open, the auto-grow effect must re-measure. Without the dep, the textarea stays at the cached height and clips multi-line input.",
+  type: "pattern",
+  scope: "project",
+  ...overrides,
+});
+
+describe("Memory Utility Floor (plan §4.5.1)", () => {
+  test("accepts a real engineering lesson", () => {
+    expect(validateMemoryQuality(ok())).toBeNull();
+  });
+
+  test("rejects comma-separated tag concatenation", () => {
+    const r = validateMemoryQuality(
+      ok({
+        title: "Consolidated procedure: procedure, add, user",
+        content:
+          "Consolidated from 5 procedure memories: foo bar baz qux many words.",
+      }),
+    );
+    expect(r?.rule).toBe("tag-concat");
+  });
+
+  test("rejects slash-separated tag concatenation", () => {
+    const r = validateMemoryQuality(
+      ok({
+        title: "Procedure: Procedure / Card / Mobile / Native",
+        content:
+          "3 related procedure entities consolidated. Original titles list goes here.",
+      }),
+    );
+    expect(r?.rule).toBe("tag-concat-slash");
+  });
+
+  test("rejects frequency-meta titles", () => {
+    const r = validateMemoryQuality(
+      ok({
+        title: "Pattern: recurring procedure (17 instances)",
+        content: "Recurring pattern: procedure entities appearing 19 times.",
+      }),
+    );
+    expect(r?.rule).toBe("frequency-meta");
+  });
+
+  test("rejects bare type prefix with empty content after colon", () => {
+    const r = validateMemoryQuality(
+      ok({
+        title: "Memory:",
+        content:
+          "Not enough substance here for any kind of memory entry value.",
+      }),
+    );
+    expect(r?.rule).toBe("bare-type-prefix");
+  });
+
+  test("rejects self-referential operational notes", () => {
+    const r = validateMemoryQuality(
+      ok({
+        title: "Auto-consolidation produces tautological clusters on tags",
+        content:
+          "The consolidation pipeline clusters entities by tag overlap, but doesn't distinguish content-bearing tags from structural pipeline tags.",
+        type: "lesson",
+      }),
+    );
+    expect(r?.rule).toBe("self-referential");
+  });
+
+  test("rejects content that's too short", () => {
+    const r = validateMemoryQuality(
+      ok({
+        title: "AnnotatedTextarea auto-grow deps fix",
+        content: "Short.",
+      }),
+    );
+    expect(r?.rule).toBe("length-floor");
+  });
+
+  test("rejects under-specific titles", () => {
+    const r = validateMemoryQuality(
+      ok({
+        title: "fix the bug",
+        content:
+          "There is a bug somewhere and it should be fixed at some point in the future.",
+      }),
+    );
+    expect(r?.rule).toBe("specificity-floor");
+  });
+
+  test("rejects Agent Profile dumps", () => {
+    const r = validateMemoryQuality({
+      title: "Agent Profile: claude-code",
+      content:
+        "## claude-code Performance Profile - Total sessions: 183 - Completed: 180 (98%)",
+      type: "agent",
+    });
+    expect(r?.rule).toBe("operational-data-ban");
+  });
+
+  test("session-scope memories bypass the Floor entirely", () => {
+    const r = validateMemoryQuality({
+      title: "user wants Q3 revenue rolled up by team",
+      content: "x",
+      type: "context",
+      scope: "session:abc123",
+    });
+    expect(r).toBeNull();
+  });
+
+  test("doc-source memories bypass title checks but not length", () => {
+    const r = validateMemoryQuality({
+      title: "## API Routes",
+      content:
+        "Section heading from CLAUDE.md auto-import. Long enough body content here ok.",
+      type: "context",
+      source_trust: "document",
+    });
+    expect(r).toBeNull();
+  });
+});

package/src/__tests__/memory-park.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, test } from "bun:test";
+import {
+  fitToBudget,
+  type ParkInput,
+  relevanceFromRank,
+  rescore,
+} from "../memory-park.js";
+
+const NOW = new Date("2026-05-08T12:00:00Z");
+
+function entity(
+  partial: Partial<ParkInput> & {
+    id: string;
+    title?: string;
+    content?: string;
+  },
+): ParkInput & { id: string; title?: string; content?: string } {
+  return {
+    id: partial.id,
+    type: partial.type ?? "pattern",
+    importance: partial.importance,
+    last_accessed_at: partial.last_accessed_at,
+    created_at: partial.created_at,
+    title: partial.title,
+    content: partial.content,
+  };
+}
+
+describe("memory-park rescore", () => {
+  test("fresh + high-importance pattern beats stale + low-importance pattern", () => {
+    const fresh = entity({
+      id: "fresh",
+      type: "pattern",
+      importance: 9,
+      last_accessed_at: "2026-05-08T11:00:00Z",
+    });
+    const stale = entity({
+      id: "stale",
+      type: "pattern",
+      importance: 4,
+      last_accessed_at: "2024-05-08T11:00:00Z", // 2y old
+    });
+    const out = rescore([stale, fresh], { now: NOW });
+    expect(out[0]?.entity.id).toBe("fresh");
+    expect(out[1]?.entity.id).toBe("stale");
+    expect(out[0]?.score).toBeGreaterThan(out[1]?.score ?? 0);
+  });
+
+  test("preferences never decay (tau=Infinity → recency=1)", () => {
+    const ancient = entity({
+      id: "p",
+      type: "preference",
+      importance: 9,
+      last_accessed_at: "2020-01-01T00:00:00Z",
+    });
+    const out = rescore([ancient], { now: NOW });
+    expect(out[0]?.recency).toBe(1);
+  });
+
+  test("caller-supplied relevance dominates when weight is high", () => {
+    const a = entity({
+      id: "a",
+      type: "pattern",
+      importance: 5,
+      last_accessed_at: "2026-04-01T00:00:00Z",
+    });
+    const b = entity({
+      id: "b",
+      type: "pattern",
+      importance: 9,
+      last_accessed_at: "2026-04-01T00:00:00Z",
+    });
+    const relevance = new Map([
+      ["a", 1.0],
+      ["b", 0.0],
+    ]);
+    const out = rescore([a, b], { now: NOW, relevance });
+    expect(out[0]?.entity.id).toBe("a");
+  });
+
+  test("missing importance falls back to per-type default", () => {
+    const e = entity({
+      id: "p",
+      type: "preference", // default 9
+      importance: null,
+      last_accessed_at: "2026-05-08T11:00:00Z",
+    });
+    const out = rescore([e], { now: NOW });
+    expect(out[0]?.importance).toBeCloseTo(0.9);
+  });
+
+  test("clamps importance to [1,10]", () => {
+    const tooLow = entity({ id: "lo", type: "pattern", importance: -5 });
+    const tooHigh = entity({ id: "hi", type: "pattern", importance: 99 });
+    const out = rescore([tooLow, tooHigh], { now: NOW });
+    const lo = out.find((s) => s.entity.id === "lo");
+    const hi = out.find((s) => s.entity.id === "hi");
+    expect(lo?.importance).toBeCloseTo(0.1);
+    expect(hi?.importance).toBeCloseTo(1.0);
+  });
+
+  test("score is α·relevance + β·recency + γ·importance", () => {
+    const e = entity({
+      id: "x",
+      type: "pattern",
+      importance: 5,
+      last_accessed_at: "2026-05-08T11:00:00Z", // very fresh
+    });
+    const out = rescore([e], {
+      now: NOW,
+      relevance: new Map([["x", 1.0]]),
+    });
+    const r = out[0]!;
+    const expected = 0.55 * r.relevance + 0.25 * r.recency + 0.2 * r.importance;
+    expect(r.score).toBeCloseTo(expected, 5);
+  });
+});
+
+describe("memory-park relevanceFromRank (hybrid retrieval bridge)", () => {
+  test("top-ranked entity gets relevance 1.0", () => {
+    const ranked = [{ id: "a" }, { id: "b" }, { id: "c" }];
+    const map = relevanceFromRank(ranked);
+    expect(map.get("a")).toBeCloseTo(1.0);
+  });
+
+  test("relevance decays exponentially with rank", () => {
+    const ranked = Array.from({ length: 20 }, (_, i) => ({ id: `r${i}` }));
+    const map = relevanceFromRank(ranked, 10);
+    expect(map.get("r0")).toBeCloseTo(1.0);
+    expect(map.get("r10")).toBeCloseTo(Math.exp(-1));
+    expect(map.get("r20")).toBeUndefined();
+  });
+
+  test("hybrid-ranked top-1 dominates Park rescore over a stale high-importance pattern", () => {
+    const matchedByQuery = entity({
+      id: "match",
+      type: "pattern",
+      importance: 5,
+      last_accessed_at: "2025-05-08T11:00:00Z",
+    });
+    const stalePopular = entity({
+      id: "popular",
+      type: "pattern",
+      importance: 9,
+      last_accessed_at: "2024-05-08T11:00:00Z",
+    });
+    const ranked = [{ id: "match" }, { id: "popular" }];
+    const relevance = relevanceFromRank(ranked);
+    const scored = rescore([stalePopular, matchedByQuery], {
+      now: NOW,
+      relevance,
+    });
+    expect(scored[0]?.entity.id).toBe("match");
+  });
+
+  test("custom decay scales the falloff curve", () => {
+    const ranked = Array.from({ length: 5 }, (_, i) => ({ id: `r${i}` }));
+    const tight = relevanceFromRank(ranked, 1);
+    const loose = relevanceFromRank(ranked, 100);
+    expect(tight.get("r1")).toBeLessThan(loose.get("r1") ?? 0);
+  });
+});
+
+describe("memory-park fitToBudget", () => {
+  test("returns prefix that fits within token budget", () => {
+    const ents = [
+      entity({
+        id: "1",
+        type: "pattern",
+        title: "x".repeat(40),
+        content: "y".repeat(40),
+      }),
+      entity({
+        id: "2",
+        type: "pattern",
+        title: "x".repeat(40),
+        content: "y".repeat(40),
+      }),
+      entity({
+        id: "3",
+        type: "pattern",
+        title: "x".repeat(40),
+        content: "y".repeat(40),
+      }),
+    ];
+    const scored = rescore(ents, { now: NOW });
+    // Each entity ~ (40/4) + (40/4) + 4 = 24 tokens
+    const fit = fitToBudget(scored, 50);
+    expect(fit.length).toBe(2);
+  });
+
+  test("always includes top result even if over budget", () => {
+    const big = entity({
+      id: "big",
+      type: "pattern",
+      title: "x".repeat(2000),
+      content: "y".repeat(2000),
+    });
+    const scored = rescore([big], { now: NOW });
+    const fit = fitToBudget(scored, 10);
+    expect(fit.length).toBe(1);
+    expect(fit[0]?.entity.id).toBe("big");
+  });
+
+  test("zero or negative budget returns empty", () => {
+    const ents = [
+      entity({ id: "1", type: "pattern", title: "abc", content: "def" }),
+    ];
+    const scored = rescore(ents, { now: NOW });
+    expect(fitToBudget(scored, 0)).toHaveLength(0);
+    expect(fitToBudget(scored, -10)).toHaveLength(0);
+  });
+});

package/src/__tests__/memory-session.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  isSessionScope,
+  resolveSessionScope,
+  sessionScopeFor,
+} from "../memory-session.js";
+
+describe("resolveSessionScope", () => {
+  it("returns undefined when caller did not pass a scope", () => {
+    expect(resolveSessionScope(undefined, "abc-123")).toBeUndefined();
+  });
+
+  it("passes a non-alias scope through unchanged", () => {
+    expect(resolveSessionScope("project", "abc-123")).toBe("project");
+    expect(resolveSessionScope("private", undefined)).toBe("private");
+    expect(resolveSessionScope("workspace", "abc-123")).toBe("workspace");
+    expect(resolveSessionScope("global", undefined)).toBe("global");
+  });
+
+  it("resolves the 'session' alias to session:<id> when a session is active", () => {
+    expect(
+      resolveSessionScope("session", "11111111-1111-1111-1111-111111111111"),
+    ).toBe("session:11111111-1111-1111-1111-111111111111");
+  });
+
+  it("throws when 'session' alias is used without an active session", () => {
+    expect(() => resolveSessionScope("session", undefined)).toThrow(
+      /requires an active agent session/i,
+    );
+    expect(() => resolveSessionScope("session", "")).toThrow(
+      /requires an active agent session/i,
+    );
+  });
+
+  it("does not auto-bind any other scope to the active session", () => {
+    expect(resolveSessionScope("project", "abc-123")).toBe("project");
+    expect(resolveSessionScope("private", "abc-123")).toBe("private");
+  });
+});
+
+describe("isSessionScope", () => {
+  it("recognizes concrete session:<id> values", () => {
+    expect(isSessionScope("session:abc-123")).toBe(true);
+    expect(isSessionScope("session:11111111-1111-1111-1111-111111111111")).toBe(
+      true,
+    );
+  });
+
+  it("rejects the bare 'session' alias (not yet resolved)", () => {
+    expect(isSessionScope("session")).toBe(false);
+    expect(isSessionScope("session:")).toBe(false);
+  });
+
+  it("rejects standard scopes", () => {
+    expect(isSessionScope("private")).toBe(false);
+    expect(isSessionScope("project")).toBe(false);
+    expect(isSessionScope("workspace")).toBe(false);
+    expect(isSessionScope("global")).toBe(false);
+  });
+
+  it("rejects non-string inputs", () => {
+    expect(isSessionScope(undefined)).toBe(false);
+    expect(isSessionScope(null)).toBe(false);
+  });
+});
+
+describe("sessionScopeFor", () => {
+  it("constructs the canonical scope value for a session id", () => {
+    expect(sessionScopeFor("abc-123")).toBe("session:abc-123");
+  });
+
+  it("output round-trips through isSessionScope", () => {
+    const scope = sessionScopeFor("11111111-1111-1111-1111-111111111111");
+    expect(isSessionScope(scope)).toBe(true);
+  });
+});