@gethmy/mcp 2.2.0 → 2.2.2

package/dist/lib/__tests__/auto-session.test.js

@@ -29,16 +29,16 @@ describe("auto-start", () => {
         await trackActivity(CARD_A, { autoStart: true, client: client });
         expect(client.startAgentSession).toHaveBeenCalledTimes(1);
         expect(client.startAgentSession).toHaveBeenCalledWith(CARD_A, {
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
             status: "working",
         });
         expect(getActiveSessions().size).toBe(1);
         const session = getActiveSessions().get(CARD_A);
         expect(session).toBeDefined();
         expect(session.isExplicit).toBe(false);
-        expect(session.agentIdentifier).toBe("auto");
-        expect(session.agentName).toBe("Auto-detected Agent");
+        expect(session.agentIdentifier).toBe("unknown");
+        expect(session.agentName).toBe("Unknown Agent");
     });
     test("does NOT trigger on autoStart=false", async () => {
         const client = makeMockClient();
@@ -68,7 +68,7 @@ describe("auto-start", () => {
         await trackActivity(CARD_A, { autoStart: true, client: client });
         // Should still be tracked despite API error
         expect(getActiveSessions().size).toBe(1);
-        expect(getActiveSessions().get(CARD_A).agentIdentifier).toBe("auto");
+        expect(getActiveSessions().get(CARD_A).agentIdentifier).toBe("unknown");
     });
     test("uses clientGetter when no client in options", async () => {
         const client = makeMockClient();
@@ -222,8 +222,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now() - INACTIVITY_TIMEOUT_MS - 1000,
             lastActivityAt: Date.now() - INACTIVITY_TIMEOUT_MS - 1000,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         checkInactivity();
         // autoEndSession is fire-and-forget in checkInactivity, wait for it
@@ -241,8 +241,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(), // just now — well within timeout
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         checkInactivity();
         expect(client.endAgentSession).not.toHaveBeenCalled();
@@ -273,8 +273,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now() - INACTIVITY_TIMEOUT_MS - 5000,
             lastActivityAt: Date.now() - INACTIVITY_TIMEOUT_MS - 5000,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // CARD_B — still active
         getActiveSessions().set(CARD_B, {
@@ -282,8 +282,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now() - 1000,
             lastActivityAt: Date.now() - 1000,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // CARD_C — timed out but explicit
         getActiveSessions().set(CARD_C, {
@@ -312,8 +312,8 @@ describe("inactivity timeout", () => {
             startedAt: 0,
             lastActivityAt: 0,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // Should not throw
         checkInactivity();
@@ -330,8 +330,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now() - INACTIVITY_TIMEOUT_MS - 5000,
             lastActivityAt: Date.now() - INACTIVITY_TIMEOUT_MS - 5000,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // Refresh activity
         await trackActivity(CARD_A, { autoStart: false });
@@ -351,8 +351,8 @@ describe("markExplicit", () => {
         expect(getActiveSessions().get(CARD_A).isExplicit).toBe(false);
         markExplicit(CARD_A);
         expect(getActiveSessions().get(CARD_A).isExplicit).toBe(true);
-        // agentIdentifier should remain "auto" since it was auto-started
-        expect(getActiveSessions().get(CARD_A).agentIdentifier).toBe("auto");
+        // agentIdentifier should remain "unknown" since no clientInfo was provided
+        expect(getActiveSessions().get(CARD_A).agentIdentifier).toBe("unknown");
     });
     test("creates new tracking entry for unknown card", () => {
         initAutoSession(mock(async () => { }), () => makeMockClient());
@@ -406,8 +406,8 @@ describe("shutdown", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         await shutdownAllSessions();
         expect(client.endAgentSession).toHaveBeenCalledWith(CARD_A, {
@@ -425,8 +425,8 @@ describe("shutdown", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         getActiveSessions().set(CARD_B, {
             cardId: CARD_B,
@@ -449,8 +449,8 @@ describe("shutdown", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // Should not throw
         await shutdownAllSessions();
@@ -473,16 +473,16 @@ describe("shutdown", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         getActiveSessions().set(CARD_B, {
             cardId: CARD_B,
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         await shutdownAllSessions();
         // Both should be removed from tracking despite first API error
@@ -595,8 +595,8 @@ describe("edge cases", () => {
             startedAt: 0,
             lastActivityAt: 0,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         checkInactivity();
         await new Promise((r) => setTimeout(r, 50));
@@ -615,8 +615,8 @@ describe("edge cases", () => {
             startedAt: 0,
             lastActivityAt: 0,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         checkInactivity();
         await new Promise((r) => setTimeout(r, 50));

package/dist/lib/api-client.js

@@ -536,6 +536,122 @@ export class HarmonyApiClient {
     async generateApiKey(name) {
         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) {
+        const { assembleContext, cacheManifest, generatePrompt } = await loadPromptModules();
+        // Fetch card data
+        const cardResult = await this.getCard(options.cardId);
+        const cardData = cardResult.card;
+        // Try to get column info
+        let columnData = null;
+        const projectIdForBoard = options.projectId || cardData.project_id;
+        if (projectIdForBoard) {
+            try {
+                const board = await this.getBoard(projectIdForBoard, { summary: true });
+                const column = board.columns.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;
+        let assemblyId;
+        let memories;
+        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.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,
+        };
+    }
+}
+// Cached dynamic imports for context-assembly and prompt-builder
+let _promptModules = 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
 let client = null;

package/dist/lib/auto-session.js

@@ -4,7 +4,36 @@
  * 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", "Codex", etc. are
+ * detected automatically — no hardcoded fallback needed.
  */
+/** Well-known MCP client names → human-friendly display names */
+const CLIENT_DISPLAY_NAMES = {
+    "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) {
+    return name.toLowerCase().replace(/\s+/g, "-");
+}
+/** Resolve agent identity from MCP client info */
+export function resolveAgentIdentity(info) {
+    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",
@@ -21,14 +50,17 @@ const activeSessions = new Map();
 let inactivityTimer = null;
 let endCallback = null;
 let clientGetter = null;
+let clientInfoGetter = 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, getClient) {
+export function initAutoSession(callback, getClient, getClientInfo) {
     endCallback = callback;
     clientGetter = getClient;
+    clientInfoGetter = getClientInfo ?? null;
     if (inactivityTimer)
         clearInterval(inactivityTimer);
     inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
@@ -60,11 +92,14 @@ export async function trackActivity(cardId, options) {
     for (const otherCardId of toEnd) {
         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",
         });
     }
@@ -76,8 +111,8 @@ export async function trackActivity(cardId, options) {
         startedAt: now,
         lastActivityAt: now,
         isExplicit: false,
-        agentIdentifier: "auto",
-        agentName: "Auto-detected Agent",
+        agentIdentifier,
+        agentName,
     });
 }
 /**
@@ -134,6 +169,7 @@ export function destroyAutoSession() {
     activeSessions.clear();
     endCallback = null;
     clientGetter = null;
+    clientInfoGetter = null;
 }
 /**
  * Get a snapshot of active sessions (for testing/debugging).

package/dist/lib/cli.js

@@ -15,6 +15,11 @@ program
     .command("serve")
     .description("Start the MCP server (stdio transport)")
     .action(async () => {
+    if (!isConfigured()) {
+        console.error("No API key configured.");
+        console.error("Run: npx @gethmy/mcp setup");
+        process.exit(1);
+    }
     await refreshSkills();
     const server = new HarmonyMCPServer();
     await server.run();
@@ -109,6 +114,8 @@ program
     .option("-p, --project <id>", "Set project context")
     .option("--skip-context", "Skip workspace/project selection")
     .option("--skip-docs", "Skip project docs scaffold/verification")
+    .option("--new", "Create a new account (skip the choice prompt)")
+    .option("-n, --name <name>", "Full name (for account creation)")
     .action(async (options) => {
     await runSetup({
         force: options.force,
@@ -124,6 +131,8 @@ program
         projectId: options.project,
         skipContext: options.skipContext,
         skipDocs: options.skipDocs,
+        newAccount: options.new,
+        name: options.name,
     });
 });
 program.parse();

package/dist/lib/onboard.js

@@ -0,0 +1,36 @@
+import { requestWithBearer, signupUser } from "./api-client.js";
+import { getApiUrl } from "./config.js";
+export async function onboardNewUser(params) {
+    const { email, password, fullName, workspaceName = `${fullName}'s Workspace`, projectName = "My First Board", template = "kanban", keyName = "mcp-agent", apiUrl = getApiUrl(), } = params;
+    // 1. Signup
+    const signupResult = await signupUser(apiUrl, {
+        email,
+        password,
+        full_name: fullName,
+    });
+    const token = signupResult.session.access_token;
+    // 2. Create workspace
+    const workspaceResult = await requestWithBearer(apiUrl, token, "POST", "/workspaces", {
+        name: workspaceName,
+    });
+    // 3. Create project
+    const projectResult = await requestWithBearer(apiUrl, token, "POST", "/projects", {
+        workspaceId: workspaceResult.workspace.id,
+        name: projectName,
+        template,
+    });
+    // 4. Generate API key
+    const keyResult = await requestWithBearer(apiUrl, token, "POST", "/api-keys", {
+        name: keyName,
+    });
+    return {
+        user: signupResult.user,
+        workspace: workspaceResult.workspace,
+        project: projectResult.project,
+        columns: projectResult.columns,
+        apiKey: {
+            rawKey: keyResult.rawKey,
+            prefix: keyResult.apiKey.prefix,
+        },
+    };
+}