@gethmy/mcp 2.3.0 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/mcp",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "MCP server for Harmony Kanban board - enables AI coding agents to manage your boards",
   "publishConfig": {
     "access": "public"
@@ -50,7 +50,7 @@
     "bun": ">=1.0.0"
   },
   "scripts": {
-    "build": "bun build src/index.ts src/cli.ts --outdir dist --target node && tsc --outDir dist/lib --declaration false --skipLibCheck --noCheck",
+    "build": "bun build src/index.ts src/cli.ts --outdir dist --target node && bun build src/*.ts src/tui/*.ts --outdir dist/lib --root src --target node --external bun",
     "build:bun": "bun build src/index.ts src/http.ts src/remote.ts src/cli.ts --outdir dist --target bun",
     "serve:remote": "bun src/remote.ts",
     "dev": "bun --watch src/index.ts",

package/src/api-client.ts

@@ -502,7 +502,6 @@ export class HarmonyApiClient {
       phase?: string;
       filesChanged?: number;
       costCents?: number;
-      recentActions?: { action: string; ts: string }[];
     },
   ): Promise<{ session: unknown; created: boolean }> {
     return this.request("POST", `/cards/${cardId}/agent-context`, data);
@@ -518,6 +517,43 @@ export class HarmonyApiClient {
     return this.request("DELETE", `/cards/${cardId}/agent-context`, data);
   }
 
+  async flushActivityLog(
+    cardId: string,
+    data: {
+      sessionId: string;
+      entries: {
+        phase?: string;
+        eventType: string;
+        toolName?: string;
+        description: string;
+        metadata?: Record<string, unknown>;
+        createdAt?: string;
+      }[];
+    },
+  ): Promise<{ inserted: number }> {
+    return this.request("POST", `/cards/${cardId}/agent-activity-log`, data);
+  }
+
+  async getActivityLog(
+    cardId: string,
+    sessionId: string,
+  ): Promise<{
+    entries: {
+      id: string;
+      phase: string | null;
+      eventType: string;
+      toolName: string | null;
+      description: string;
+      metadata: Record<string, unknown>;
+      createdAt: string;
+    }[];
+  }> {
+    return this.request(
+      "GET",
+      `/cards/${cardId}/agent-activity-log?sessionId=${sessionId}`,
+    );
+  }
+
   async getAgentSession(
     cardId: string,
     options?: { includeEnded?: boolean },

package/src/memory-cleanup.ts

@@ -130,6 +130,11 @@ const ALL_STEPS: CleanupStep[] = [
   "backfill",
 ];
 
+const MS_PER_DAY = 1000 * 60 * 60 * 24;
+const MAX_ENTITIES_FETCH = 200;
+const DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
+const CONCURRENCY_LIMIT = 5;
+
 // ---------------------------------------------------------------------------
 // Main orchestrator
 // ---------------------------------------------------------------------------
@@ -163,7 +168,7 @@ export async function runMemoryCleanup(
     const listResult = await client.listMemoryEntities({
       workspace_id: workspaceId,
       project_id: projectId,
-      limit: 200,
+      limit: MAX_ENTITIES_FETCH,
     });
     entities = (listResult.entities || []) as MemoryEntity[];
     report.summary.totalEntities = entities.length;
@@ -186,8 +191,11 @@ export async function runMemoryCleanup(
           try {
             await client.deleteMemoryEntity(item.id);
             report.steps.prune.pruned++;
-          } catch {
-            // Non-fatal
+          } catch (err) {
+            report.errors.push({
+              step: "prune",
+              message: `Failed to delete ${item.id}: ${(err as Error).message}`,
+            });
           }
         }
         report.summary.actionsTaken += report.steps.prune.pruned;
@@ -237,8 +245,11 @@ export async function runMemoryCleanup(
           try {
             await client.deleteMemoryEntity(item.id);
             report.steps.orphans.removed++;
-          } catch {
-            // Non-fatal
+          } catch (err) {
+            report.errors.push({
+              step: "orphans",
+              message: `Failed to delete ${item.id}: ${(err as Error).message}`,
+            });
           }
         }
         report.summary.actionsTaken += report.steps.orphans.removed;
@@ -266,8 +277,11 @@ export async function runMemoryCleanup(
           try {
             await client.deleteMemoryEntity(pair.removeId);
             report.steps.duplicates.resolved++;
-          } catch {
-            // Non-fatal
+          } catch (err) {
+            report.errors.push({
+              step: "duplicates",
+              message: `Failed to delete ${pair.removeId}: ${(err as Error).message}`,
+            });
           }
         }
         report.summary.actionsTaken += report.steps.duplicates.resolved;
@@ -325,8 +339,7 @@ function runPruneStep(
   const stale: PruneStepResult["items"] = [];
 
   for (const entity of drafts) {
-    const ageDays =
-      (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
+    const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
     if (ageDays < maxAgeDays) continue;
 
     const lifecycle = evaluateLifecycle(entity);
@@ -353,31 +366,38 @@ async function runOrphanStep(
   const candidates = entities.filter((e) => {
     if (e.memory_tier === "reference") return false;
     if (e.access_count >= 2) return false;
-    const ageDays =
-      (now - new Date(e.created_at).getTime()) / (1000 * 60 * 60 * 24);
+    const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY;
     return ageDays >= orphanAgeDays;
   });
 
-  for (const entity of candidates) {
-    try {
-      const related = await client.getRelatedEntities(entity.id);
-      const totalRelations =
-        (related.outgoing?.length || 0) + (related.incoming?.length || 0);
-      if (totalRelations > 0) continue;
-
-      const ageDays =
-        (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
-      result.items.push({
-        id: entity.id,
-        title: entity.title,
-        type: entity.type,
-        tier: entity.memory_tier,
-        ageDays: Math.round(ageDays),
-        accessCount: entity.access_count,
-      });
-      result.orphansFound++;
-    } catch {
-      // Non-fatal: skip this entity
+  // Check relations in concurrent batches
+  for (let i = 0; i < candidates.length; i += CONCURRENCY_LIMIT) {
+    const batch = candidates.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(
+      batch.map(async (entity) => {
+        const related = await client.getRelatedEntities(entity.id);
+        const totalRelations =
+          (related.outgoing?.length || 0) + (related.incoming?.length || 0);
+        if (totalRelations > 0) return null;
+
+        const ageDays =
+          (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
+        return {
+          id: entity.id,
+          title: entity.title,
+          type: entity.type,
+          tier: entity.memory_tier,
+          ageDays: Math.round(ageDays),
+          accessCount: entity.access_count,
+        };
+      }),
+    );
+
+    for (const r of results) {
+      if (r.status === "fulfilled" && r.value) {
+        result.items.push(r.value);
+        result.orphansFound++;
+      }
     }
   }
 
@@ -398,28 +418,42 @@ async function runDuplicateStep(
 
   const seenPairs = new Set<string>();
   const flaggedForRemoval = new Set<string>();
+  const entityMap = new Map(entities.map((e) => [e.id, e]));
 
+  // Pre-fetch similarities in concurrent batches
+  type SimilarMatch = {
+    id: string;
+    type: string;
+    title: string;
+    content: string;
+    confidence: number;
+  };
+  const similarityMap = new Map<string, SimilarMatch[]>();
+  for (let i = 0; i < entities.length; i += CONCURRENCY_LIMIT) {
+    const batch = entities.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(
+      batch.map(async (entity) => {
+        const similar = await findSimilarEntities(
+          client,
+          entity.title,
+          entity.content,
+          workspaceId,
+          { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] },
+        );
+        return { entityId: entity.id, similar };
+      }),
+    );
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        similarityMap.set(r.value.entityId, r.value.similar);
+      }
+    }
+  }
+
+  // Process pairs sequentially (flaggedForRemoval creates dependencies)
   for (const entity of entities) {
     if (flaggedForRemoval.has(entity.id)) continue;
-
-    let similar: Array<{
-      id: string;
-      type: string;
-      title: string;
-      content: string;
-      confidence: number;
-    }>;
-    try {
-      similar = await findSimilarEntities(
-        client,
-        entity.title,
-        entity.content,
-        workspaceId,
-        { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] },
-      );
-    } catch {
-      continue;
-    }
+    const similar = similarityMap.get(entity.id) || [];
 
     for (const match of similar) {
       if (flaggedForRemoval.has(match.id)) continue;
@@ -429,11 +463,11 @@ async function runDuplicateStep(
       seenPairs.add(pairKey);
 
       const sim = titleSimilarity(entity.title, match.title);
-      if (sim < 0.85) continue;
+      if (sim < DUPLICATE_SIMILARITY_THRESHOLD) continue;
 
       // Keep the one with higher confidence, more accesses, or higher tier
       const entityScore = entityQualityScore(entity);
-      const matchEntity = entities.find((e) => e.id === match.id);
+      const matchEntity = entityMap.get(match.id);
       const matchScore = matchEntity
         ? entityQualityScore(matchEntity)
         : match.confidence;
@@ -506,6 +540,12 @@ function generateHealthReport(report: CleanupReport): string {
     "",
   ];
 
+  if (report.summary.totalEntities >= MAX_ENTITIES_FETCH) {
+    lines.push(
+      `> **Note:** Entity count hit the ${MAX_ENTITIES_FETCH} fetch limit. Some entities may not have been analyzed.\n`,
+    );
+  }
+
   // Prune
   if (report.steps.prune) {
     const p = report.steps.prune;

package/src/server.ts

@@ -4024,9 +4024,24 @@ async function handleToolCall(
       const projectId =
         (args.projectId as string) || deps.getActiveProjectId() || undefined;
 
+      const validSteps = [
+        "prune",
+        "consolidate",
+        "orphans",
+        "duplicates",
+        "backfill",
+      ];
+      const rawSteps = args.steps as string[] | undefined;
+      const steps = rawSteps?.filter((s) => validSteps.includes(s));
+      if (rawSteps && steps && steps.length < rawSteps.length) {
+        const invalid = rawSteps.filter((s) => !validSteps.includes(s));
+        // Will appear in report.errors via the healthReport
+        console.warn(`Unknown cleanup steps ignored: ${invalid.join(", ")}`);
+      }
+
       const report = await runMemoryCleanup(client, workspaceId, projectId, {
         dryRun: args.dryRun as boolean | undefined,
-        steps: args.steps as string[] | undefined,
+        steps,
         maxAgeDays: args.maxAgeDays as number | undefined,
         minClusterSize: args.minClusterSize as number | undefined,
         orphanAgeDays: args.orphanAgeDays as number | undefined,