harmony-mcp 1.0.4 → 1.1.1

package/dist/cli.js

@@ -13786,6 +13786,386 @@ var require_dist = __commonJS((exports, module) => {
   exports.default = formatsPlugin;
 });
 
+// src/init.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+var HARMONY_WORKFLOW_PROMPT = `# Harmony Card Workflow
+
+You are starting work on a Harmony card. Follow this workflow:
+
+## Step 1: Find the Card
+
+The user provided: $ARGUMENTS
+
+Parse the card reference:
+- If it starts with \`#\` followed by numbers (e.g., \`#42\`), use \`harmony_get_card_by_short_id\` with the number
+- If it looks like a UUID, use \`harmony_get_card\` directly
+- Otherwise, use \`harmony_search_cards\` to find by name
+
+## Step 2: Move to In Progress
+
+Once you have the card:
+1. Get the board using \`harmony_get_board\` to find the "In Progress" column ID
+2. Use \`harmony_move_card\` to move the card to "In Progress"
+
+## Step 3: Add Agent Label
+
+1. From the board response, find the label named "agent"
+2. Use \`harmony_add_label_to_card\` to add it to the card
+
+## Step 4: Start Agent Session
+
+After adding the agent label, start tracking your work session:
+1. Use \`harmony_start_agent_session\` with:
+   - \`cardId\`: The card ID
+   - \`agentIdentifier\`: Your agent identifier
+   - \`agentName\`: Your agent name
+   - \`currentTask\`: A brief description of what you're about to do
+
+This enables the timer badge on the card to show your progress in real-time.
+
+## Step 5: Display Card Details
+
+Show the user:
+- Card title and short ID
+- Description (if any)
+- Priority
+- Current labels
+- Due date (if set)
+
+## Step 6: Implement the Solution
+
+Based on the card's title and description:
+1. Understand what needs to be done
+2. Explore the codebase as needed
+3. Implement the required changes
+4. Test the changes
+
+**During implementation, update your progress periodically:**
+- Use \`harmony_update_agent_progress\` to report:
+  - \`progressPercent\`: Estimated completion (0-100)
+  - \`currentTask\`: What you're currently doing
+  - \`blockers\`: Any issues blocking progress (set \`status: "blocked"\` if blocked)
+
+## Step 7: Complete Work
+
+When implementation is complete:
+1. Use \`harmony_end_agent_session\` with:
+   - \`cardId\`: The card ID
+   - \`status\`: "completed"
+   - \`progressPercent\`: 100
+2. Use \`harmony_move_card\` to move the card to the "Review" column
+3. Summarize what was accomplished
+
+## Important Notes
+- Always read the card description carefully before starting
+- If the task is unclear, ask for clarification
+- Make commits as appropriate during implementation
+- The "agent" label indicates AI is working on the card
+- Update progress at meaningful milestones, not constantly
+- If you need to pause work, call \`harmony_end_agent_session\` with \`status: "paused"\`
+`;
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function writeFileIfNotExists(filePath, content, force) {
+  if (existsSync(filePath) && !force) {
+    return { created: false, skipped: true };
+  }
+  ensureDir(dirname(filePath));
+  writeFileSync(filePath, content, "utf-8");
+  return { created: true, skipped: false };
+}
+function mergeJsonFile(filePath, updates, force) {
+  if (!existsSync(filePath)) {
+    ensureDir(dirname(filePath));
+    writeFileSync(filePath, JSON.stringify(updates, null, 2), "utf-8");
+    return { created: true, skipped: false, merged: false };
+  }
+  try {
+    const existing = JSON.parse(readFileSync(filePath, "utf-8"));
+    if (updates.mcpServers && existing.mcpServers) {
+      if (existing.mcpServers.harmony && !force) {
+        return { created: false, skipped: true, merged: false };
+      }
+      existing.mcpServers = { ...existing.mcpServers, ...updates.mcpServers };
+    } else {
+      Object.assign(existing, updates);
+    }
+    writeFileSync(filePath, JSON.stringify(existing, null, 2), "utf-8");
+    return { created: false, skipped: false, merged: true };
+  } catch {
+    if (force) {
+      writeFileSync(filePath, JSON.stringify(updates, null, 2), "utf-8");
+      return { created: true, skipped: false, merged: false };
+    }
+    return { created: false, skipped: true, merged: false };
+  }
+}
+function initClaude(cwd, force) {
+  const result = {
+    agent: "claude",
+    filesCreated: [],
+    filesSkipped: []
+  };
+  const commandContent = `---
+description: Start working on a Harmony card (moves to In Progress, adds agent label)
+argument-hint: <card-reference>
+---
+
+${HARMONY_WORKFLOW_PROMPT.replace("Your agent identifier", "claude-code").replace("Your agent name", "Claude Code")}
+`;
+  const commandPath = join(cwd, ".claude", "commands", "hmy.md");
+  const { created, skipped } = writeFileIfNotExists(commandPath, commandContent, force);
+  if (created)
+    result.filesCreated.push(commandPath);
+  if (skipped)
+    result.filesSkipped.push(commandPath);
+  const globalConfigPath = join(homedir(), ".claude", "settings.json");
+  const mcpConfig = {
+    mcpServers: {
+      harmony: {
+        command: "harmony-mcp",
+        args: ["serve"]
+      }
+    }
+  };
+  const configResult = mergeJsonFile(globalConfigPath, mcpConfig, force);
+  if (configResult.created || configResult.merged) {
+    result.filesCreated.push(globalConfigPath);
+  } else if (configResult.skipped) {
+    result.filesSkipped.push(globalConfigPath);
+  }
+  return result;
+}
+function initCodex(cwd, force) {
+  const result = {
+    agent: "codex",
+    filesCreated: [],
+    filesSkipped: []
+  };
+  const agentsContent = `# Harmony Integration
+
+This project uses Harmony for task management. When working on tasks:
+
+## Starting Work on a Card
+
+When given a card reference (e.g., #42 or a card name), follow this workflow:
+
+1. Use \`harmony_get_card_by_short_id\` or \`harmony_search_cards\` to find the card
+2. Move the card to "In Progress" using \`harmony_move_card\`
+3. Add the "agent" label using \`harmony_add_label_to_card\`
+4. Start a session with \`harmony_start_agent_session\` (agentIdentifier: "codex", agentName: "OpenAI Codex")
+5. Show the card details to the user
+6. Implement the solution based on the card description
+7. Update progress periodically with \`harmony_update_agent_progress\`
+8. When done, call \`harmony_end_agent_session\` and move to "Review"
+
+## Available Harmony Tools
+
+- \`harmony_get_card\`, \`harmony_get_card_by_short_id\`, \`harmony_search_cards\` - Find cards
+- \`harmony_move_card\` - Move cards between columns
+- \`harmony_add_label_to_card\`, \`harmony_remove_label_from_card\` - Manage labels
+- \`harmony_start_agent_session\`, \`harmony_update_agent_progress\`, \`harmony_end_agent_session\` - Track work
+- \`harmony_get_board\` - Get board state
+`;
+  const agentsPath = join(cwd, "AGENTS.md");
+  const { created: agentsCreated, skipped: agentsSkipped } = writeFileIfNotExists(agentsPath, agentsContent, force);
+  if (agentsCreated)
+    result.filesCreated.push(agentsPath);
+  if (agentsSkipped)
+    result.filesSkipped.push(agentsPath);
+  const promptContent = `---
+name: hmy
+description: Start working on a Harmony card
+arguments:
+  - name: card
+    description: Card reference (#42, UUID, or name)
+    required: true
+---
+
+${HARMONY_WORKFLOW_PROMPT.replace("$ARGUMENTS", "{{card}}").replace("Your agent identifier", "codex").replace("Your agent name", "OpenAI Codex")}
+`;
+  const promptsDir = join(homedir(), ".codex", "prompts");
+  const promptPath = join(promptsDir, "hmy.md");
+  const { created: promptCreated, skipped: promptSkipped } = writeFileIfNotExists(promptPath, promptContent, force);
+  if (promptCreated)
+    result.filesCreated.push(promptPath);
+  if (promptSkipped)
+    result.filesSkipped.push(promptPath);
+  const configPath = join(homedir(), ".codex", "config.toml");
+  const mcpConfigSection = `
+# Harmony MCP Server
+[mcp_servers.harmony]
+command = "harmony-mcp"
+args = ["serve"]
+`;
+  if (!existsSync(configPath)) {
+    ensureDir(dirname(configPath));
+    writeFileSync(configPath, mcpConfigSection, "utf-8");
+    result.filesCreated.push(configPath);
+  } else {
+    const existingConfig = readFileSync(configPath, "utf-8");
+    if (!existingConfig.includes("[mcp_servers.harmony]")) {
+      writeFileSync(configPath, existingConfig + `
+` + mcpConfigSection, "utf-8");
+      result.filesCreated.push(configPath);
+    } else if (force) {
+      const updated = existingConfig.replace(/\[mcp_servers\.harmony\][\s\S]*?(?=\[|$)/, mcpConfigSection.trim() + `
+
+`);
+      writeFileSync(configPath, updated, "utf-8");
+      result.filesCreated.push(configPath);
+    } else {
+      result.filesSkipped.push(configPath);
+    }
+  }
+  return result;
+}
+function initCursor(cwd, force) {
+  const result = {
+    agent: "cursor",
+    filesCreated: [],
+    filesSkipped: []
+  };
+  const mcpConfigPath = join(cwd, ".cursor", "mcp.json");
+  const mcpConfig = {
+    mcpServers: {
+      harmony: {
+        command: "harmony-mcp",
+        args: ["serve"]
+      }
+    }
+  };
+  const mcpResult = mergeJsonFile(mcpConfigPath, mcpConfig, force);
+  if (mcpResult.created || mcpResult.merged) {
+    result.filesCreated.push(mcpConfigPath);
+  } else if (mcpResult.skipped) {
+    result.filesSkipped.push(mcpConfigPath);
+  }
+  const ruleContent = `---
+description: Harmony card workflow rule
+globs:
+  - "**/*"
+alwaysApply: false
+---
+
+# Harmony Integration
+
+When the user asks you to work on a Harmony card (references like #42, card names, or UUIDs):
+
+${HARMONY_WORKFLOW_PROMPT.replace("$ARGUMENTS", "the card reference").replace("Your agent identifier", "cursor").replace("Your agent name", "Cursor AI")}
+`;
+  const rulePath = join(cwd, ".cursor", "rules", "harmony.mdc");
+  const { created: ruleCreated, skipped: ruleSkipped } = writeFileIfNotExists(rulePath, ruleContent, force);
+  if (ruleCreated)
+    result.filesCreated.push(rulePath);
+  if (ruleSkipped)
+    result.filesSkipped.push(rulePath);
+  return result;
+}
+function initWindsurf(cwd, force) {
+  const result = {
+    agent: "windsurf",
+    filesCreated: [],
+    filesSkipped: []
+  };
+  const globalMcpPath = join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+  const mcpConfig = {
+    mcpServers: {
+      harmony: {
+        command: "harmony-mcp",
+        args: ["serve"],
+        disabled: false,
+        alwaysAllow: []
+      }
+    }
+  };
+  const mcpResult = mergeJsonFile(globalMcpPath, mcpConfig, force);
+  if (mcpResult.created || mcpResult.merged) {
+    result.filesCreated.push(globalMcpPath);
+  } else if (mcpResult.skipped) {
+    result.filesSkipped.push(globalMcpPath);
+  }
+  const ruleContent = `---
+trigger: model_decision
+description: Activate when user asks to work on a Harmony card (references like #42, card names, or task management)
+---
+
+# Harmony Card Workflow
+
+When working on a Harmony card:
+
+${HARMONY_WORKFLOW_PROMPT.replace("$ARGUMENTS", "the card reference").replace("Your agent identifier", "windsurf").replace("Your agent name", "Windsurf AI")}
+`;
+  const rulePath = join(cwd, ".windsurf", "rules", "harmony.md");
+  const { created: ruleCreated, skipped: ruleSkipped } = writeFileIfNotExists(rulePath, ruleContent, force);
+  if (ruleCreated)
+    result.filesCreated.push(rulePath);
+  if (ruleSkipped)
+    result.filesSkipped.push(rulePath);
+  return result;
+}
+function initHarmony(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const force = options.force || false;
+  const agents = options.agents || ["claude", "codex", "cursor", "windsurf"];
+  const results = [];
+  for (const agent of agents) {
+    try {
+      switch (agent) {
+        case "claude":
+          results.push(initClaude(cwd, force));
+          break;
+        case "codex":
+          results.push(initCodex(cwd, force));
+          break;
+        case "cursor":
+          results.push(initCursor(cwd, force));
+          break;
+        case "windsurf":
+          results.push(initWindsurf(cwd, force));
+          break;
+        default:
+          results.push({
+            agent,
+            filesCreated: [],
+            filesSkipped: [],
+            error: `Unknown agent: ${agent}`
+          });
+      }
+    } catch (error) {
+      results.push({
+        agent,
+        filesCreated: [],
+        filesSkipped: [],
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+function detectAgents(cwd = process.cwd()) {
+  const detected = [];
+  if (existsSync(join(cwd, ".claude")) || existsSync(join(homedir(), ".claude"))) {
+    detected.push("claude");
+  }
+  if (existsSync(join(cwd, "AGENTS.md")) || existsSync(join(homedir(), ".codex"))) {
+    detected.push("codex");
+  }
+  if (existsSync(join(cwd, ".cursor"))) {
+    detected.push("cursor");
+  }
+  if (existsSync(join(cwd, ".windsurf")) || existsSync(join(cwd, ".windsurfrules")) || existsSync(join(homedir(), ".codeium", "windsurf"))) {
+    detected.push("windsurf");
+  }
+  return detected;
+}
+var SUPPORTED_AGENTS = ["claude", "codex", "cursor", "windsurf"];
+
 // ../../node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -24850,19 +25230,19 @@ var coerce = {
 };
 var NEVER2 = INVALID;
 // src/config.ts
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 var DEFAULT_API_URL = "https://gethmy.com/api";
 function getConfigDir() {
-  return join(homedir(), ".harmony-mcp");
+  return join2(homedir2(), ".harmony-mcp");
 }
 function getConfigPath() {
-  return join(getConfigDir(), "config.json");
+  return join2(getConfigDir(), "config.json");
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return {
       apiKey: null,
       apiUrl: DEFAULT_API_URL,
@@ -24871,7 +25251,7 @@ function loadConfig() {
     };
   }
   try {
-    const data = readFileSync(configPath, "utf-8");
+    const data = readFileSync2(configPath, "utf-8");
     const config2 = JSON.parse(data);
     return {
       apiKey: config2.apiKey || null,
@@ -24891,12 +25271,12 @@ function loadConfig() {
 function saveConfig(config2) {
   const configDir = getConfigDir();
   const configPath = getConfigPath();
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true, mode: 448 });
+  if (!existsSync2(configDir)) {
+    mkdirSync2(configDir, { recursive: true, mode: 448 });
   }
   const existingConfig = loadConfig();
   const newConfig = { ...existingConfig, ...config2 };
-  writeFileSync(configPath, JSON.stringify(newConfig, null, 2), { mode: 384 });
+  writeFileSync2(configPath, JSON.stringify(newConfig, null, 2), { mode: 384 });
 }
 function getApiKey() {
   const config2 = loadConfig();
@@ -25025,6 +25405,22 @@ class HarmonyApiClient {
   async deleteSubtask(subtaskId) {
     return this.request("DELETE", `/subtasks/${subtaskId}`);
   }
+  async startAgentSession(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/agent-context`, data);
+  }
+  async updateAgentProgress(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/agent-context`, data);
+  }
+  async endAgentSession(cardId, data) {
+    return this.request("DELETE", `/cards/${cardId}/agent-context`, data);
+  }
+  async getAgentSession(cardId, options) {
+    const params = new URLSearchParams;
+    if (options?.includeEnded)
+      params.set("include_ended", "true");
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.request("GET", `/cards/${cardId}/agent-context${query}`);
+  }
   async processNLU(data) {
     return this.request("POST", "/nlu", data);
   }
@@ -25309,6 +25705,60 @@ var TOOLS = {
       },
       required: ["command"]
     }
+  },
+  harmony_start_agent_session: {
+    description: "Start an agent work session on a card. Tracks progress, status, and blockers. Call this when beginning work on a card.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cardId: { type: "string", description: "Card ID to start working on" },
+        agentIdentifier: { type: "string", description: "Unique agent identifier (e.g., claude-code)" },
+        agentName: { type: "string", description: "Human-readable agent name (e.g., Claude Code)" },
+        currentTask: { type: "string", description: "Initial task description" },
+        estimatedMinutesRemaining: { type: "number", description: "Estimated time to completion in minutes" }
+      },
+      required: ["cardId", "agentIdentifier", "agentName"]
+    }
+  },
+  harmony_update_agent_progress: {
+    description: "Update progress on an active agent session. Use to report progress percentage, current task, blockers, or status changes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cardId: { type: "string", description: "Card ID with active session" },
+        agentIdentifier: { type: "string", description: "Agent identifier" },
+        agentName: { type: "string", description: "Agent name" },
+        status: { type: "string", enum: ["working", "blocked", "paused"], description: "Current status" },
+        progressPercent: { type: "number", description: "Progress percentage (0-100)" },
+        currentTask: { type: "string", description: "What the agent is currently doing" },
+        blockers: { type: "array", items: { type: "string" }, description: "List of blocking issues" },
+        estimatedMinutesRemaining: { type: "number", description: "Updated time estimate" }
+      },
+      required: ["cardId", "agentIdentifier", "agentName"]
+    }
+  },
+  harmony_end_agent_session: {
+    description: "End an agent work session on a card. Call this when work is complete or paused.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cardId: { type: "string", description: "Card ID to end session on" },
+        status: { type: "string", enum: ["completed", "paused"], description: "Final status (default: completed)" },
+        progressPercent: { type: "number", description: "Final progress percentage" }
+      },
+      required: ["cardId"]
+    }
+  },
+  harmony_get_agent_session: {
+    description: "Get the current agent session for a card, including progress, status, and blockers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cardId: { type: "string", description: "Card ID to check" },
+        includeEnded: { type: "boolean", description: "Include ended sessions in history" }
+      },
+      required: ["cardId"]
+    }
   }
 };
 var RESOURCES = [
@@ -25625,6 +26075,49 @@ Include: cards moved recently, current in-progress items, blocked or high-priori
         });
         return { success: true, ...result };
       }
+      case "harmony_start_agent_session": {
+        const cardId = exports_external.string().uuid().parse(args.cardId);
+        const agentIdentifier = exports_external.string().min(1).parse(args.agentIdentifier);
+        const agentName = exports_external.string().min(1).parse(args.agentName);
+        const result = await client2.startAgentSession(cardId, {
+          agentIdentifier,
+          agentName,
+          status: "working",
+          currentTask: args.currentTask,
+          estimatedMinutesRemaining: args.estimatedMinutesRemaining
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_update_agent_progress": {
+        const cardId = exports_external.string().uuid().parse(args.cardId);
+        const agentIdentifier = exports_external.string().min(1).parse(args.agentIdentifier);
+        const agentName = exports_external.string().min(1).parse(args.agentName);
+        const result = await client2.updateAgentProgress(cardId, {
+          agentIdentifier,
+          agentName,
+          status: args.status,
+          progressPercent: args.progressPercent,
+          currentTask: args.currentTask,
+          blockers: args.blockers,
+          estimatedMinutesRemaining: args.estimatedMinutesRemaining
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_end_agent_session": {
+        const cardId = exports_external.string().uuid().parse(args.cardId);
+        const result = await client2.endAgentSession(cardId, {
+          status: args.status || "completed",
+          progressPercent: args.progressPercent
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_get_agent_session": {
+        const cardId = exports_external.string().uuid().parse(args.cardId);
+        const result = await client2.getAgentSession(cardId, {
+          includeEnded: args.includeEnded === true || args.includeEnded === "true"
+        });
+        return { success: true, ...result };
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
@@ -25733,4 +26226,144 @@ program.command("set-project <projectId>").description("Set the active project c
   setActiveProject(projectId);
   console.log(`Active project set to: ${projectId}`);
 });
+program.command("init").description("Initialize Harmony MCP for AI coding agents (Claude Code, Codex, Cursor, Windsurf)").option("-a, --agent <agents...>", `Agent(s) to configure: ${SUPPORTED_AGENTS.join(", ")}`).option("--all", "Configure all supported agents").option("--detect", "Auto-detect installed agents and configure them").option("-f, --force", "Overwrite existing configuration files").option("-d, --directory <path>", "Project directory (default: current directory)").action(async (options) => {
+  console.log(`Harmony MCP Initialization
+`);
+  let agents = [];
+  const cwd = options.directory || process.cwd();
+  if (options.all) {
+    agents = [...SUPPORTED_AGENTS];
+    console.log(`Configuring all supported agents...
+`);
+  } else if (options.detect) {
+    agents = detectAgents(cwd);
+    if (agents.length === 0) {
+      console.log("No AI coding agents detected in this project.");
+      console.log(`Supported agents: ${SUPPORTED_AGENTS.join(", ")}`);
+      console.log(`
+Use --all to configure all agents, or --agent to specify specific ones.`);
+      process.exit(0);
+    }
+    console.log(`Detected agents: ${agents.join(", ")}
+`);
+  } else if (options.agent) {
+    agents = options.agent.filter((a) => SUPPORTED_AGENTS.includes(a));
+    const invalid = options.agent.filter((a) => !SUPPORTED_AGENTS.includes(a));
+    if (invalid.length > 0) {
+      console.log(`Warning: Unknown agent(s) ignored: ${invalid.join(", ")}`);
+    }
+    if (agents.length === 0) {
+      console.log(`No valid agents specified. Supported: ${SUPPORTED_AGENTS.join(", ")}`);
+      process.exit(1);
+    }
+  } else {
+    console.log(`Select AI coding agents to configure:
+`);
+    SUPPORTED_AGENTS.forEach((agent, i) => {
+      const descriptions = {
+        claude: "Claude Code - Anthropic CLI agent",
+        codex: "OpenAI Codex - OpenAI coding agent",
+        cursor: "Cursor - AI-powered IDE",
+        windsurf: "Windsurf - Codeium AI IDE"
+      };
+      console.log(`  ${i + 1}. ${agent} - ${descriptions[agent]}`);
+    });
+    console.log(`  a. All agents`);
+    console.log(`  d. Auto-detect
+`);
+    const answer = await prompt("Enter your choice (1-4, a, d, or comma-separated numbers): ");
+    if (answer.toLowerCase() === "a") {
+      agents = [...SUPPORTED_AGENTS];
+    } else if (answer.toLowerCase() === "d") {
+      agents = detectAgents(cwd);
+      if (agents.length === 0) {
+        console.log(`
+No agents detected. Using all agents.`);
+        agents = [...SUPPORTED_AGENTS];
+      } else {
+        console.log(`
+Detected: ${agents.join(", ")}`);
+      }
+    } else {
+      const selections = answer.split(/[,\s]+/).map((s) => parseInt(s.trim(), 10) - 1);
+      agents = selections.filter((i) => i >= 0 && i < SUPPORTED_AGENTS.length).map((i) => SUPPORTED_AGENTS[i]);
+      if (agents.length === 0) {
+        console.log("No valid selections. Exiting.");
+        rl.close();
+        process.exit(1);
+      }
+    }
+    rl.close();
+  }
+  console.log(`
+Initializing for: ${agents.join(", ")}
+`);
+  const results = initHarmony({
+    agents,
+    cwd,
+    force: options.force
+  });
+  let hasErrors = false;
+  for (const result of results) {
+    console.log(`
+${result.agent.toUpperCase()}:`);
+    if (result.error) {
+      console.log(`  ❌ Error: ${result.error}`);
+      hasErrors = true;
+      continue;
+    }
+    if (result.filesCreated.length > 0) {
+      console.log("  Created:");
+      result.filesCreated.forEach((f) => console.log(`    ✓ ${f}`));
+    }
+    if (result.filesSkipped.length > 0) {
+      console.log("  Skipped (already exists, use --force to overwrite):");
+      result.filesSkipped.forEach((f) => console.log(`    - ${f}`));
+    }
+    if (result.filesCreated.length === 0 && result.filesSkipped.length === 0) {
+      console.log("  No changes made");
+    }
+  }
+  console.log(`
+` + "─".repeat(60));
+  if (!isConfigured()) {
+    console.log(`
+⚠️  API key not configured!`);
+    console.log("Run: harmony-mcp configure");
+    console.log(`Generate an API key at: https://gethmy.com → Settings → API Keys
+`);
+  } else {
+    console.log(`
+✓ Harmony MCP is ready to use!`);
+  }
+  console.log(`
+Usage by agent:`);
+  if (agents.includes("claude")) {
+    console.log(`
+  Claude Code:`);
+    console.log("    Use /hmy <card-reference> to start working on a card");
+    console.log('    Example: /hmy #42 or /hmy "Fix login bug"');
+  }
+  if (agents.includes("codex")) {
+    console.log(`
+  Codex:`);
+    console.log("    Use /prompts:hmy <card-reference> to start working on a card");
+    console.log("    Or reference cards naturally - AGENTS.md provides context");
+  }
+  if (agents.includes("cursor")) {
+    console.log(`
+  Cursor:`);
+    console.log("    MCP tools are available automatically");
+    console.log("    Rules activate when you mention Harmony cards");
+  }
+  if (agents.includes("windsurf")) {
+    console.log(`
+  Windsurf:`);
+    console.log("    MCP tools are available automatically");
+    console.log("    Rules activate when you mention Harmony cards");
+  }
+  console.log(`
+`);
+  process.exit(hasErrors ? 1 : 0);
+});
 program.parse();