@gethmy/mcp 2.2.0 → 2.2.2

package/dist/lib/server.js

@@ -4,14 +4,14 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { detectContradictions, extractLearnings, extractMidSessionLearnings, } from "./active-learning.js";
-import { getClient, requestWithBearer, resetClient, signupUser, } from "./api-client.js";
+import { getClient, resetClient, signupUser, } from "./api-client.js";
 import { AUTO_START_TRIGGERS, destroyAutoSession, initAutoSession, markExplicit, shutdownAllSessions, trackActivity, untrack, } from "./auto-session.js";
 import { getActiveProjectId, getActiveWorkspaceId, getApiUrl, getMemoryDir, getUserEmail, isConfigured, saveConfig, setActiveProject, setActiveWorkspace, } from "./config.js";
 import { consolidateMemories } from "./consolidation.js";
 import { assembleContext, cacheManifest, computeRelevanceScore, getCachedManifest, mapToContextEntity, recordContextFeedback, trackSessionAssembly, } from "./context-assembly.js";
 import { autoExpandGraph } from "./graph-expansion.js";
 import { runLifecycleMaintenance } from "./lifecycle-maintenance.js";
-import { generatePrompt, } from "./prompt-builder.js";
+import { onboardNewUser } from "./onboard.js";
 const memorySessions = new Map();
 function initMemorySession(cardId, agentIdentifier, agentName) {
     memorySessions.set(cardId, {
@@ -169,18 +169,22 @@ const TOOLS = {
         },
     },
     harmony_move_card: {
-        description: "Move a card to a different column or position",
+        description: "Move a card to a different column or position. Provide either columnId (UUID) or columnName (e.g. 'Review', 'Done').",
         inputSchema: {
             type: "object",
             properties: {
                 cardId: { type: "string", description: "Card ID to move" },
-                columnId: { type: "string", description: "Target column ID" },
+                columnId: { type: "string", description: "Target column ID (UUID)" },
+                columnName: {
+                    type: "string",
+                    description: "Target column name (e.g. 'To Do', 'In Progress', 'Review', 'Done'). Used if columnId is not provided.",
+                },
                 position: {
                     type: "number",
                     description: "Position in column (0-indexed)",
                 },
             },
-            required: ["cardId", "columnId"],
+            required: ["cardId"],
         },
     },
     harmony_archive_card: {
@@ -313,14 +317,21 @@ const TOOLS = {
         },
     },
     harmony_add_label_to_card: {
-        description: "Add a label to a card",
+        description: "Add a label to a card. Provide labelId directly, or labelName to look up (or auto-create) the label by name.",
         inputSchema: {
             type: "object",
             properties: {
                 cardId: { type: "string" },
-                labelId: { type: "string" },
+                labelId: {
+                    type: "string",
+                    description: "Label ID (optional if labelName provided)",
+                },
+                labelName: {
+                    type: "string",
+                    description: "Label name — will look up or create if not found",
+                },
             },
-            required: ["cardId", "labelId"],
+            required: ["cardId"],
         },
     },
     harmony_remove_label_from_card: {
@@ -1704,6 +1715,19 @@ export function registerHandlers(server, deps) {
         throw new Error(`Unknown resource: ${uri}`);
     });
 }
+/** Resolve a column name to its ID. Prefers exact match, falls back to substring. */
+async function resolveColumnByName(client, projectId, columnName) {
+    const board = await client.getBoard(projectId, { summary: true });
+    const columns = board.columns;
+    const lower = columnName.toLowerCase();
+    const col = columns.find((c) => c.name.toLowerCase() === lower) ||
+        columns.find((c) => c.name.toLowerCase().includes(lower));
+    if (!col) {
+        const available = columns.map((c) => c.name).join(", ");
+        throw new Error(`Column "${columnName}" not found. Available columns: ${available}`);
+    }
+    return col;
+}
 async function handleToolCall(name, args, deps) {
     // Unauthenticated tools that don't require an API key
     const unauthenticatedTools = ["harmony_signup", "harmony_onboard"];
@@ -1758,19 +1782,36 @@ async function handleToolCall(name, args, deps) {
         }
         case "harmony_move_card": {
             const cardId = z.string().uuid().parse(args.cardId);
-            const columnId = z.string().uuid().parse(args.columnId);
             const position = args.position !== undefined
                 ? z.number().int().min(0).parse(args.position)
                 : undefined;
+            // Resolve columnId — accept UUID directly or resolve from columnName
+            let columnId;
+            let resolvedProjectId;
+            if (args.columnId) {
+                columnId = z.string().uuid().parse(args.columnId);
+            }
+            else if (args.columnName) {
+                const columnName = z.string().parse(args.columnName);
+                const { card: cardForProject } = await client.getCard(cardId);
+                resolvedProjectId = cardForProject
+                    ?.project_id;
+                if (!resolvedProjectId)
+                    throw new Error("Card has no project");
+                const col = await resolveColumnByName(client, resolvedProjectId, columnName);
+                columnId = col.id;
+            }
+            else {
+                throw new Error("Either columnId or columnName is required");
+            }
             const result = await client.moveCard(cardId, columnId, position);
             // Auto-end active agent session when moving to Review or Done
             let sessionEnded = false;
             try {
                 const { card } = result;
-                if (card?.project_id) {
-                    const board = await client.getBoard(card.project_id, {
-                        summary: true,
-                    });
+                const projectId = card?.project_id || resolvedProjectId;
+                if (projectId) {
+                    const board = await client.getBoard(projectId, { summary: true });
                     const columns = board.columns;
                     const destCol = columns.find((c) => c.id === columnId);
                     const colName = destCol?.name?.toLowerCase() || "";
@@ -1871,7 +1912,38 @@ async function handleToolCall(name, args, deps) {
         }
         case "harmony_add_label_to_card": {
             const cardId = z.string().uuid().parse(args.cardId);
-            const labelId = z.string().uuid().parse(args.labelId);
+            let labelId = args.labelId
+                ? z.string().uuid().parse(args.labelId)
+                : undefined;
+            const labelName = args.labelName
+                ? z.string().min(1).max(100).parse(args.labelName)
+                : undefined;
+            // If labelName provided without labelId, look up or create the label
+            if (!labelId && labelName) {
+                const { card } = await client.getCard(cardId);
+                const projectId = card.project_id;
+                if (!projectId) {
+                    throw new Error("Cannot resolve label by name: card has no project_id");
+                }
+                if (projectId) {
+                    const board = await client.getBoard(projectId, { summary: true });
+                    const labels = board.labels;
+                    const existing = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+                    if (existing) {
+                        labelId = existing.id;
+                    }
+                    else {
+                        const created = await client.createLabel(projectId, {
+                            name: labelName,
+                            color: "#57b8a5",
+                        });
+                        labelId = created.label.id;
+                    }
+                }
+            }
+            if (!labelId) {
+                throw new Error("Either labelId or labelName must be provided");
+            }
             await client.addLabelToCard(cardId, labelId);
             return { success: true };
         }
@@ -2016,10 +2088,18 @@ async function handleToolCall(name, args, deps) {
                         }
                         if (addLabels?.length) {
                             for (const labelName of addLabels) {
-                                const label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+                                let label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+                                if (!label && projectId) {
+                                    const created = await client.createLabel(projectId, {
+                                        name: labelName,
+                                        color: "#57b8a5",
+                                    });
+                                    label = created
+                                        .label;
+                                }
                                 if (label) {
                                     await client.addLabelToCard(cardId, label.id);
-                                    labelsAdded.push(label.name);
+                                    labelsAdded.push(label.name ?? labelName);
                                 }
                             }
                         }
@@ -2177,29 +2257,25 @@ async function handleToolCall(name, args, deps) {
             // Final flush of any pending memory actions before ending the session
             await flushMemoryActions(client, cardId);
             cleanupMemorySession(cardId);
-            const result = await client.endAgentSession(cardId, {
-                status: sessionStatus,
-                progressPercent: endProgressPercent,
-            });
-            // Remove from auto-session tracking
+            // End the session — tolerate failure (e.g., session already ended or not found)
+            let result = { session: null };
+            let sessionEndError = null;
+            try {
+                result = await client.endAgentSession(cardId, {
+                    status: sessionStatus,
+                    progressPercent: endProgressPercent,
+                });
+            }
+            catch (err) {
+                sessionEndError =
+                    err instanceof Error ? err.message : "Failed to end session";
+            }
+            // Remove from auto-session tracking regardless
             untrack(cardId);
             let movedTo = null;
-            const _learningsExtracted = 0;
-            // Get card info for move and learning extraction
-            let _cardTitle = "";
-            let _cardLabels = [];
-            let _cardDescription = "";
-            let _cardSubtasks = [];
             try {
                 const { card } = await client.getCard(cardId);
                 const typedCard = card;
-                _cardTitle = typedCard.title || "";
-                _cardLabels = (typedCard.labels || []).map((l) => l.name);
-                _cardDescription = typedCard.description || "";
-                _cardSubtasks = (typedCard.subtasks || []).map((s) => ({
-                    title: s.title,
-                    done: s.done,
-                }));
                 const projectId = typedCard.project_id;
                 // Remove "agent" label when session is completed (not paused)
                 if (sessionStatus === "completed" && typedCard.labels?.length) {
@@ -2209,15 +2285,9 @@ async function handleToolCall(name, args, deps) {
                     }
                 }
                 if (moveToColumn && projectId) {
-                    const board = await client.getBoard(projectId, {
-                        summary: true,
-                    });
-                    const columns = board.columns;
-                    const col = columns.find((c) => c.name.toLowerCase().includes(moveToColumn.toLowerCase()));
-                    if (col) {
-                        await client.moveCard(cardId, col.id);
-                        movedTo = col.name;
-                    }
+                    const col = await resolveColumnByName(client, projectId, moveToColumn);
+                    await client.moveCard(cardId, col.id);
+                    movedTo = col.name;
                 }
             }
             catch {
@@ -2228,6 +2298,7 @@ async function handleToolCall(name, args, deps) {
             const pipelineResult = await runEndSessionPipeline(client, deps, cardId, sessionStatus, endProgressPercent, sessionObj);
             return {
                 success: true,
+                ...(sessionEndError && { sessionEndError }),
                 movedTo,
                 learningsExtracted: pipelineResult.learningsExtracted,
                 feedbackAdjusted: pipelineResult.feedbackAdjusted,
@@ -2261,13 +2332,10 @@ async function handleToolCall(name, args, deps) {
         }
         // Prompt generation
         case "harmony_generate_prompt": {
-            // Get card - either by UUID or short ID
-            let cardData;
-            let columnData = null;
+            // Resolve card ID — either directly or via short ID
+            let cardId;
             if (args.cardId) {
-                const cardId = z.string().uuid().parse(args.cardId);
-                const cardResult = await client.getCard(cardId);
-                cardData = cardResult.card;
+                cardId = z.string().uuid().parse(args.cardId);
             }
             else if (args.shortId !== undefined) {
                 const shortId = z.number().int().positive().parse(args.shortId);
@@ -2276,32 +2344,12 @@ async function handleToolCall(name, args, deps) {
                     throw new Error("Project ID required when using shortId. Use harmony_set_project_context or provide projectId.");
                 }
                 const cardResult = await client.getCardByShortId(projectId, shortId);
-                cardData = cardResult.card;
+                cardId = cardResult.card.id;
             }
             else {
                 throw new Error("Either cardId or shortId must be provided");
             }
-            // Try to get column info from board
-            const projectIdForBoard = args.projectId ||
-                getActiveProjectId() ||
-                cardData.project_id;
-            if (projectIdForBoard) {
-                try {
-                    const board = await client.getBoard(projectIdForBoard, {
-                        summary: true,
-                    });
-                    const columnId = cardData
-                        .column_id;
-                    const column = board.columns.find((col) => col.id === columnId);
-                    if (column) {
-                        columnData = { name: column.name };
-                    }
-                }
-                catch {
-                    // Column info not available, continue without it
-                }
-            }
-            const variant = args.variant || "execute";
+            // Parse MCP-specific context options
             const contextOptions = {};
             if (args.includeSubtasks !== undefined) {
                 contextOptions.includeSubtasks =
@@ -2316,75 +2364,21 @@ async function handleToolCall(name, args, deps) {
                     args.includeDescription === true ||
                         args.includeDescription === "true";
             }
-            // Assemble context using the context assembly engine
-            let assembledContextStr;
-            let assemblyId;
-            let memories;
-            try {
-                const workspaceId = deps.getActiveWorkspaceId();
-                if (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,
-                        projectId: getActiveProjectId() || undefined,
-                        taskContext,
-                        cardLabels,
-                        cardId: cardData.id,
-                        client,
-                    });
-                    if (assembled.context) {
-                        assembledContextStr = assembled.context;
-                        assemblyId = assembled.manifest.assemblyId;
-                        cacheManifest(assembled.manifest);
-                    }
-                }
-            }
-            catch {
-                // Context assembly failed, try legacy fallback
-                try {
-                    const workspaceId = deps.getActiveWorkspaceId();
-                    if (workspaceId && cardData.title) {
-                        const memoryResult = await client.searchMemoryEntities(workspaceId, cardData.title, {
-                            project_id: getActiveProjectId() || undefined,
-                            limit: 5,
-                        });
-                        if (memoryResult.entities?.length > 0) {
-                            memories = memoryResult.entities.map((e) => {
-                                const entity = e;
-                                return {
-                                    id: entity.id,
-                                    type: entity.type,
-                                    title: entity.title,
-                                    content: entity.content,
-                                    confidence: entity.confidence,
-                                    tags: entity.tags || [],
-                                };
-                            });
-                        }
-                    }
-                }
-                catch {
-                    // Memory fetch also failed, continue without memories
-                }
-            }
-            const result = generatePrompt({
-                card: cardData,
-                column: columnData,
-                variant,
-                contextOptions,
+            // Delegate to the shared prompt generation pipeline
+            const result = await client.generateCardPrompt({
+                cardId,
+                workspaceId: deps.getActiveWorkspaceId() || "",
+                projectId: args.projectId || getActiveProjectId() || undefined,
+                variant: args.variant || "execute",
                 customConstraints: args.customConstraints,
-                memories,
-                assembledContext: assembledContextStr,
-                assemblyId,
+                contextOptions,
             });
+            // MCP-specific: cache the assembly manifest for the feedback loop
+            if (result.assemblyId) {
+                trackSessionAssembly(cardId, result.assemblyId);
+            }
             return {
                 success: true,
-                cardId: cardData.id,
-                shortId: cardData.short_id,
-                title: cardData.title,
                 ...result,
             };
         }
@@ -3150,44 +3144,28 @@ async function handleToolCall(name, args, deps) {
             const projectName = args.projectName || "My First Project";
             const template = args.template || "kanban";
             const keyName = args.keyName || "mcp-agent";
-            const apiUrl = deps.getApiUrl();
-            // 1. Signup
-            const signupResult = await signupUser(apiUrl, {
+            const result = await onboardNewUser({
                 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,
+                fullName,
+                workspaceName,
+                projectName,
                 template,
+                keyName,
+                apiUrl: deps.getApiUrl(),
             });
-            // 4. Generate API key
-            const keyResult = await requestWithBearer(apiUrl, token, "POST", "/api-keys", {
-                name: keyName,
-            });
-            // 5. Save config
-            deps.saveConfig({ apiKey: keyResult.rawKey });
-            deps.setActiveWorkspace(workspaceResult.workspace.id);
-            deps.setActiveProject(projectResult.project.id);
-            // 6. Reset client so singleton picks up new key
+            // Save config and reset client
+            deps.saveConfig({ apiKey: result.apiKey.rawKey });
+            deps.setActiveWorkspace(result.workspace.id);
+            deps.setActiveProject(result.project.id);
             deps.resetClient();
             return {
                 success: true,
-                user: signupResult.user,
-                workspace: workspaceResult.workspace,
-                project: projectResult.project,
-                columns: projectResult.columns,
-                apiKey: {
-                    rawKey: keyResult.rawKey,
-                    prefix: keyResult.apiKey.prefix,
-                },
+                user: result.user,
+                workspace: result.workspace,
+                project: result.project,
+                columns: result.columns,
+                apiKey: result.apiKey,
                 message: `Onboarding complete! Account created for ${email}. Workspace "${workspaceName}" and project "${projectName}" are ready. API key saved to config.`,
             };
         }
@@ -3267,11 +3245,14 @@ export class HarmonyMCPServer {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         console.error("Harmony MCP server running on stdio");
-        // Initialize auto-session tracking
+        // Initialize auto-session tracking with MCP client identity detection
         const configDeps = createConfigDeps();
         initAutoSession(async (client, cardId, status) => {
             await runEndSessionPipeline(client, configDeps, cardId, status);
-        }, () => getClient());
+        }, () => getClient(), () => {
+            const cv = this.server.getClientVersion();
+            return cv ? { name: cv.name, version: cv.version } : null;
+        });
         // Graceful shutdown: end all auto-sessions
         const handleShutdown = async () => {
             try {

package/dist/lib/skills.js

@@ -4,7 +4,7 @@ import { areSkillsInstalled } from "./config.js";
 export const SKILLS_VERSION = "3";
 const VERSION_MARKER_PREFIX = "<!-- skills-version:";
 /**
- * Legacy workflow prompt used by Codex, Cursor, Windsurf agents.
+ * Legacy workflow prompt used by Codex, Cursor agents.
  * Claude Code skills use the newer SKILL_DEFINITIONS content instead.
  */
 export const HARMONY_WORKFLOW_PROMPT = `# Harmony Card Workflow