@gethmy/mcp 2.1.3 → 2.2.1

package/src/api-client.ts

@@ -952,6 +952,211 @@ export class HarmonyApiClient {
   }> {
     return this.request("POST", "/api-keys", { name });
   }
+
+  // ============ PROMPT GENERATION ============
+
+  /**
+   * Generate a prompt for a card with full memory context assembly.
+   *
+   * This is the shared entry point for prompt generation — used by the MCP
+   * server tool handler and the agent daemon. It fetches the card, assembles
+   * relevant memories, and produces a role-framed prompt.
+   */
+  async generateCardPrompt(options: {
+    cardId: string;
+    workspaceId: string;
+    projectId?: string;
+    variant?: "analysis" | "draft" | "execute";
+    customConstraints?: string;
+    contextOptions?: Partial<{
+      includeSubtasks: boolean;
+      includeLinks: boolean;
+      includeDescription: boolean;
+    }>;
+  }): Promise<{
+    prompt: string;
+    variant: string;
+    category: string;
+    role: string;
+    contextSummary: {
+      hasDescription: boolean;
+      labelCount: number;
+      subtaskCount: number;
+      completedSubtasks: number;
+      linkedCardCount: number;
+      memoryCount: number;
+    };
+    tokenEstimate: number;
+    assemblyId?: string;
+    cardId: string;
+    shortId: number;
+    title: string;
+  }> {
+    const { assembleContext, cacheManifest, generatePrompt } =
+      await loadPromptModules();
+
+    // Fetch card data
+    const cardResult = await this.getCard(options.cardId);
+    const cardData = cardResult.card as CardPromptData;
+
+    // Try to get column info
+    let columnData: { name: string } | null = null;
+    const projectIdForBoard = options.projectId || cardData.project_id;
+    if (projectIdForBoard) {
+      try {
+        const board = await this.getBoard(projectIdForBoard, { summary: true });
+        const column = (
+          board.columns as Array<{ id: string; name: string }>
+        ).find((col) => col.id === cardData.column_id);
+        if (column) {
+          columnData = { name: column.name };
+        }
+      } catch {
+        // Column info not available, continue without it
+      }
+    }
+
+    const variant = options.variant || "execute";
+
+    // Assemble memory context
+    let assembledContextStr: string | undefined;
+    let assemblyId: string | undefined;
+    let memories: MemoryItem[] | undefined;
+
+    try {
+      if (options.workspaceId && cardData.title) {
+        const cardLabels = (cardData.labels || []).map((l) => l.name);
+        const taskContext = [cardData.title, cardData.description || ""]
+          .filter(Boolean)
+          .join(" ");
+
+        const assembled = await assembleContext({
+          workspaceId: options.workspaceId,
+          projectId: options.projectId,
+          taskContext,
+          cardLabels,
+          cardId: cardData.id,
+          client: this,
+        });
+
+        if (assembled.context) {
+          assembledContextStr = assembled.context;
+          assemblyId = assembled.manifest.assemblyId;
+          cacheManifest(assembled.manifest);
+        }
+      }
+    } catch (err) {
+      // Context assembly failed, try legacy fallback
+      const msg = err instanceof Error ? err.message : String(err);
+      console.debug(`[generateCardPrompt] Context assembly failed: ${msg}`);
+      try {
+        if (options.workspaceId && cardData.title) {
+          const memoryResult = await this.searchMemoryEntities(
+            options.workspaceId,
+            cardData.title,
+            {
+              project_id: options.projectId,
+              limit: 5,
+            },
+          );
+          if (memoryResult.entities?.length > 0) {
+            memories = (memoryResult.entities as MemoryItem[]).map((e) => ({
+              id: e.id,
+              type: e.type,
+              title: e.title,
+              content: e.content,
+              confidence: e.confidence,
+              tags: e.tags || [],
+            }));
+          }
+        }
+      } catch (fallbackErr) {
+        const fallbackMsg =
+          fallbackErr instanceof Error
+            ? fallbackErr.message
+            : String(fallbackErr);
+        console.debug(
+          `[generateCardPrompt] Memory fallback also failed: ${fallbackMsg}`,
+        );
+      }
+    }
+
+    const result = generatePrompt({
+      card: cardData,
+      column: columnData,
+      variant,
+      contextOptions: options.contextOptions,
+      customConstraints: options.customConstraints,
+      memories,
+      assembledContext: assembledContextStr,
+      assemblyId,
+    });
+
+    return {
+      ...result,
+      cardId: cardData.id,
+      shortId: cardData.short_id,
+      title: cardData.title,
+    };
+  }
+}
+
+// Shared types for generateCardPrompt to avoid inline assertions
+interface CardPromptData {
+  id: string;
+  short_id: number;
+  title: string;
+  description?: string | null;
+  priority: string;
+  due_date?: string | null;
+  done: boolean;
+  labels?: Array<{ name: string; color: string }>;
+  subtasks?: Array<{ title: string; completed: boolean }>;
+  links?: Array<{
+    target_card: { short_id: number; title: string };
+    display_type: string;
+    direction: "outgoing" | "incoming";
+  }>;
+  assignee?: { full_name?: string; email: string } | null;
+  column_id?: string;
+  project_id?: string;
+}
+
+interface MemoryItem {
+  id: string;
+  type: string;
+  title: string;
+  content: string;
+  confidence: number;
+  tags: string[];
+}
+
+// Cached dynamic imports for context-assembly and prompt-builder
+let _promptModules: {
+  assembleContext: Awaited<
+    typeof import("./context-assembly.js")
+  >["assembleContext"];
+  cacheManifest: Awaited<
+    typeof import("./context-assembly.js")
+  >["cacheManifest"];
+  generatePrompt: Awaited<
+    typeof import("./prompt-builder.js")
+  >["generatePrompt"];
+} | null = null;
+
+async function loadPromptModules() {
+  if (!_promptModules) {
+    const [ca, pb] = await Promise.all([
+      import("./context-assembly.js"),
+      import("./prompt-builder.js"),
+    ]);
+    _promptModules = {
+      assembleContext: ca.assembleContext,
+      cacheManifest: ca.cacheManifest,
+      generatePrompt: pb.generatePrompt,
+    };
+  }
+  return _promptModules;
 }
 
 // Singleton instance

package/src/auto-session.ts

@@ -4,6 +4,10 @@
  * Automatically detects agent session boundaries by monitoring tool calls.
  * Sessions auto-start when card-mutating tools are called, and auto-end
  * after 10 minutes of inactivity or when a different card is worked on.
+ *
+ * Agent identity is resolved from the MCP client's `initialize` handshake
+ * (clientInfo.name), so "Claude Code", "Cursor", "Windsurf", etc. are
+ * detected automatically — no hardcoded fallback needed.
  */
 
 import type { HarmonyApiClient } from "./api-client.js";
@@ -24,6 +28,43 @@ export type EndSessionCallback = (
   status: "completed" | "paused",
 ) => Promise<void>;
 
+/** MCP client identity from the `initialize` handshake */
+export interface ClientInfo {
+  name: string;
+  version?: string;
+}
+
+/** Well-known MCP client names → human-friendly display names */
+const CLIENT_DISPLAY_NAMES: Record<string, string> = {
+  "claude-code": "Claude Code",
+  "claude-desktop": "Claude Desktop",
+  cursor: "Cursor",
+  windsurf: "Windsurf",
+  cline: "Cline",
+  continue: "Continue",
+  "codex-cli": "OpenAI Codex",
+  zed: "Zed",
+  "gemini-cli": "Gemini CLI",
+};
+
+/** Derive a slug-style identifier from a client name */
+function toIdentifier(name: string): string {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+
+/** Resolve agent identity from MCP client info */
+export function resolveAgentIdentity(info: ClientInfo | null): {
+  agentIdentifier: string;
+  agentName: string;
+} {
+  if (!info?.name) {
+    return { agentIdentifier: "unknown", agentName: "Unknown Agent" };
+  }
+  const key = toIdentifier(info.name);
+  const displayName = CLIENT_DISPLAY_NAMES[key] ?? info.name; // use raw name if not in map
+  return { agentIdentifier: key, agentName: displayName };
+}
+
 /** Tools that trigger auto-start of a session */
 export const AUTO_START_TRIGGERS = new Set([
   "harmony_generate_prompt",
@@ -42,18 +83,22 @@ const activeSessions = new Map<string, TrackedSession>();
 let inactivityTimer: ReturnType<typeof setInterval> | null = null;
 let endCallback: EndSessionCallback | null = null;
 let clientGetter: (() => HarmonyApiClient) | null = null;
+let clientInfoGetter: (() => ClientInfo | null) | null = null;
 
 /**
  * Initialize auto-session tracking.
  * @param callback Called when an auto-session ends (runs the learning pipeline)
  * @param getClient Function to get the current API client
+ * @param getClientInfo Function to get MCP client identity from the initialize handshake
  */
 export function initAutoSession(
   callback: EndSessionCallback,
   getClient: () => HarmonyApiClient,
+  getClientInfo?: () => ClientInfo | null,
 ): void {
   endCallback = callback;
   clientGetter = getClient;
+  clientInfoGetter = getClientInfo ?? null;
 
   if (inactivityTimer) clearInterval(inactivityTimer);
   inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
@@ -95,11 +140,15 @@ export async function trackActivity(
     await autoEndSession(client, otherCardId, "completed");
   }
 
+  // Resolve agent identity from MCP client info
+  const info = clientInfoGetter?.() ?? null;
+  const { agentIdentifier, agentName } = resolveAgentIdentity(info);
+
   // Start a new auto-session
   try {
     await client.startAgentSession(cardId, {
-      agentIdentifier: "auto",
-      agentName: "Auto-detected Agent",
+      agentIdentifier,
+      agentName,
       status: "working",
     });
   } catch {
@@ -111,18 +160,25 @@ export async function trackActivity(
     startedAt: now,
     lastActivityAt: now,
     isExplicit: false,
-    agentIdentifier: "auto",
-    agentName: "Auto-detected Agent",
+    agentIdentifier,
+    agentName,
   });
 }
 
 /**
  * Mark a session as explicitly started (won't be auto-ended by card switching or inactivity).
+ * Optionally accepts the real agent identifier/name to store in the session.
  */
-export function markExplicit(cardId: string): void {
+export function markExplicit(
+  cardId: string,
+  options?: { agentIdentifier?: string; agentName?: string },
+): void {
   const existing = activeSessions.get(cardId);
   if (existing) {
     existing.isExplicit = true;
+    if (options?.agentIdentifier)
+      existing.agentIdentifier = options.agentIdentifier;
+    if (options?.agentName) existing.agentName = options.agentName;
   } else {
     // Track the explicit session even if we didn't auto-start it
     activeSessions.set(cardId, {
@@ -130,8 +186,8 @@ export function markExplicit(cardId: string): void {
       startedAt: Date.now(),
       lastActivityAt: Date.now(),
       isExplicit: true,
-      agentIdentifier: "explicit",
-      agentName: "Explicit Agent",
+      agentIdentifier: options?.agentIdentifier ?? "explicit",
+      agentName: options?.agentName ?? "Explicit Agent",
     });
   }
 }
@@ -169,6 +225,7 @@ export function destroyAutoSession(): void {
   activeSessions.clear();
   endCallback = null;
   clientGetter = null;
+  clientInfoGetter = null;
 }
 
 /**

package/src/cli.ts

@@ -113,7 +113,7 @@ program
     } else {
       console.log("Status: Not configured\n");
       console.log("Run: npx @gethmy/mcp setup");
-      console.log("Get an API key at: https://gethmy.com/user/keys");
+      console.log("Get an API key at: https://app.gethmy.com/user/keys");
     }
   });
 

package/src/config.ts

@@ -20,7 +20,7 @@ export interface LocalConfig {
   projectId: string | null;
 }
 
-const DEFAULT_API_URL = "https://gethmy.com/api";
+const DEFAULT_API_URL = "https://app.gethmy.com/api";
 const LOCAL_CONFIG_FILENAME = ".harmony-mcp.json";
 
 export function getConfigDir(): string {

package/src/http.ts

@@ -23,6 +23,7 @@ app.use(
   cors({
     origin: [
       "https://gethmy.com",
+      "https://app.gethmy.com",
       "http://localhost:8080",
       "http://localhost:3000",
     ],

package/src/prompt-builder.ts

@@ -438,6 +438,9 @@ export function generatePrompt(
   roleFraming.focus.forEach((f) => {
     sections.push(`- ${f}`);
   });
+  sections.push(
+    `- **Memory:** When you discover important domain knowledge, architectural decisions, or infrastructure details, store them via \`harmony_remember\`. Focus on durable knowledge that future agents would benefit from — not ephemeral task details (those are auto-extracted from your session).`,
+  );
 
   // Output suggestions
   sections.push(`\n## Suggested Outputs`);

package/src/remote.ts

@@ -10,7 +10,7 @@
  *   Claude.ai → POST https://mcp.gethmy.com/mcp (Bearer: hmy_xxx)
  *
  * Env vars:
- *   HARMONY_API_URL - Harmony API base URL (default: https://gethmy.com/api)
+ *   HARMONY_API_URL - Harmony API base URL (default: https://app.gethmy.com/api)
  *   PORT            - Listen port (default: 3002)
  */
 
@@ -25,7 +25,8 @@ import { registerHandlers, type ToolDeps } from "./server.js";
 // ---------------------------------------------------------------------------
 // Config from env
 // ---------------------------------------------------------------------------
-const HARMONY_API_URL = process.env.HARMONY_API_URL || "https://gethmy.com/api";
+const HARMONY_API_URL =
+  process.env.HARMONY_API_URL || "https://app.gethmy.com/api";
 const PORT = parseInt(process.env.PORT || "3002", 10);
 
 // ---------------------------------------------------------------------------