@gethmy/mcp 2.3.1 → 2.3.2

package/dist/lib/skills.js

@@ -1,13 +1,227 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_API_URL = "https://app.gethmy.com/api";
+var LOCAL_CONFIG_FILENAME = ".harmony-mcp.json";
+function getConfigDir() {
+  return join(homedir(), ".harmony-mcp");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function getLocalConfigPath(cwd) {
+  return join(cwd || process.cwd(), LOCAL_CONFIG_FILENAME);
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return {
+      apiKey: null,
+      apiUrl: DEFAULT_API_URL,
+      activeWorkspaceId: null,
+      activeProjectId: null,
+      userEmail: null,
+      memoryDir: null
+    };
+  }
+  try {
+    const data = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(data);
+    return {
+      apiKey: config.apiKey || null,
+      apiUrl: config.apiUrl || DEFAULT_API_URL,
+      activeWorkspaceId: config.activeWorkspaceId || null,
+      activeProjectId: config.activeProjectId || null,
+      userEmail: config.userEmail || null,
+      memoryDir: config.memoryDir || null
+    };
+  } catch {
+    return {
+      apiKey: null,
+      apiUrl: DEFAULT_API_URL,
+      activeWorkspaceId: null,
+      activeProjectId: null,
+      userEmail: null,
+      memoryDir: null
+    };
+  }
+}
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true, mode: 448 });
+  }
+  const existingConfig = loadConfig();
+  const newConfig = { ...existingConfig, ...config };
+  writeFileSync(configPath, JSON.stringify(newConfig, null, 2), {
+    mode: 384
+  });
+}
+function loadLocalConfig(cwd) {
+  const localConfigPath = getLocalConfigPath(cwd);
+  if (!existsSync(localConfigPath)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(localConfigPath, "utf-8");
+    const config = JSON.parse(data);
+    return {
+      workspaceId: config.workspaceId || null,
+      projectId: config.projectId || null
+    };
+  } catch {
+    return null;
+  }
+}
+function saveLocalConfig(config, cwd) {
+  const localConfigPath = getLocalConfigPath(cwd);
+  const existingConfig = loadLocalConfig(cwd) || {
+    workspaceId: null,
+    projectId: null
+  };
+  const newConfig = { ...existingConfig, ...config };
+  const cleanConfig = {};
+  if (newConfig.workspaceId)
+    cleanConfig.workspaceId = newConfig.workspaceId;
+  if (newConfig.projectId)
+    cleanConfig.projectId = newConfig.projectId;
+  writeFileSync(localConfigPath, JSON.stringify(cleanConfig, null, 2));
+}
+function hasLocalConfig(cwd) {
+  return existsSync(getLocalConfigPath(cwd));
+}
+function getApiKey() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    throw new Error(`Not configured. Run "npx @gethmy/mcp setup" to set your API key.
+` + "You can generate an API key at https://gethmy.com → Settings → API Keys.");
+  }
+  return config.apiKey;
+}
+function getApiUrl() {
+  const config = loadConfig();
+  return config.apiUrl;
+}
+function getUserEmail() {
+  const config = loadConfig();
+  return config.userEmail;
+}
+function setUserEmail(email) {
+  saveConfig({ userEmail: email });
+}
+function setActiveWorkspace(workspaceId, options) {
+  if (options?.local) {
+    saveLocalConfig({ workspaceId }, options.cwd);
+  } else {
+    saveConfig({ activeWorkspaceId: workspaceId });
+  }
+}
+function setActiveProject(projectId, options) {
+  if (options?.local) {
+    saveLocalConfig({ projectId }, options.cwd);
+  } else {
+    saveConfig({ activeProjectId: projectId });
+  }
+}
+function getActiveWorkspaceId(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  if (localConfig?.workspaceId) {
+    return localConfig.workspaceId;
+  }
+  return loadConfig().activeWorkspaceId;
+}
+function getActiveProjectId(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  if (localConfig?.projectId) {
+    return localConfig.projectId;
+  }
+  return loadConfig().activeProjectId;
+}
+function isConfigured() {
+  const config = loadConfig();
+  return !!config.apiKey;
+}
+function areSkillsInstalled(cwd) {
+  const home = homedir();
+  const workingDir = cwd || process.cwd();
+  const foundPaths = [];
+  const globalSkillsDir = join(home, ".agents", "skills");
+  const globalSkillPath = join(globalSkillsDir, "hmy", "SKILL.md");
+  if (existsSync(globalSkillPath)) {
+    foundPaths.push(globalSkillPath);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const claudeGlobalSkill = join(home, ".claude", "skills", "hmy.md");
+  if (existsSync(claudeGlobalSkill)) {
+    foundPaths.push(claudeGlobalSkill);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const claudeGlobalSkillAlt = join(home, ".claude", "skills", "hmy", "SKILL.md");
+  if (existsSync(claudeGlobalSkillAlt)) {
+    foundPaths.push(claudeGlobalSkillAlt);
+    return { installed: true, location: "global", paths: foundPaths };
+  }
+  const localSkillPath = join(workingDir, ".claude", "skills", "hmy.md");
+  if (existsSync(localSkillPath)) {
+    foundPaths.push(localSkillPath);
+    return { installed: true, location: "local", paths: foundPaths };
+  }
+  const localSkillPathAlt = join(workingDir, ".claude", "skills", "hmy", "SKILL.md");
+  if (existsSync(localSkillPathAlt)) {
+    foundPaths.push(localSkillPathAlt);
+    return { installed: true, location: "local", paths: foundPaths };
+  }
+  return { installed: false, location: null, paths: [] };
+}
+function hasProjectContext(cwd) {
+  const localConfig = loadLocalConfig(cwd);
+  return !!(localConfig?.workspaceId || localConfig?.projectId);
+}
+function getMemoryDir() {
+  const config = loadConfig();
+  if (config.memoryDir)
+    return config.memoryDir;
+  return join(homedir(), ".harmony", "memory");
+}
+
+// src/skills.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname } from "node:path";
-import { areSkillsInstalled } from "./config.js";
-export const SKILLS_VERSION = "4";
-const VERSION_MARKER_PREFIX = "<!-- skills-version:";
-/**
- * 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
+var SKILLS_VERSION = "4";
+var VERSION_MARKER_PREFIX = "<!-- skills-version:";
+var HARMONY_WORKFLOW_PROMPT = `# Harmony Card Workflow
 
 Start work on a Harmony card. Card reference: $ARGUMENTS
 
@@ -82,10 +296,7 @@ If pausing: \`harmony_end_agent_session\` with \`status: "paused"\`
 
 **AI:** \`harmony_generate_prompt\`, \`harmony_process_command\`
 `;
-/**
- * New Claude Code skill content with intent detection.
- */
-const HMY_SKILL_CONTENT = `# Harmony Card Workflow
+var HMY_SKILL_CONTENT = `# Harmony Card Workflow
 
 User input: $ARGUMENTS
 
@@ -242,7 +453,7 @@ Proceed normally without a session. No action needed.
 
 **AI:** \`harmony_generate_prompt\`, \`harmony_process_command\`
 `;
-const HMY_PLAN_CONTENT = `# Harmony Plan Workflow
+var HMY_PLAN_CONTENT = `# Harmony Plan Workflow
 
 Create a new plan or work on an existing one. Argument: $ARGUMENTS
 
@@ -455,139 +666,111 @@ Report the result:
 **Planning:** \`harmony_create_plan\`, \`harmony_advance_plan\`, \`harmony_update_plan\`
 **Execution:** \`harmony_create_card\`, \`harmony_update_card\`
 `;
-export const SKILL_DEFINITIONS = {
-    hmy: {
-        name: "hmy",
-        description: "Work with Harmony cards — create, view, update, or start working on them. Use when given a card reference like #42, or commands like create, move, update.",
-        argumentHint: "<command or card-reference>",
-        content: HMY_SKILL_CONTENT,
-    },
-    "hmy-plan": {
-        name: "hmy-plan",
-        description: "Create a new plan or work on an existing one. Use when asked to plan a feature, execute a plan, review a plan, or given a plan reference.",
-        argumentHint: "[plan name, ID, or topic to plan]",
-        content: HMY_PLAN_CONTENT,
-    },
+var SKILL_DEFINITIONS = {
+  hmy: {
+    name: "hmy",
+    description: "Work with Harmony cards — create, view, update, or start working on them. Use when given a card reference like #42, or commands like create, move, update.",
+    argumentHint: "<command or card-reference>",
+    content: HMY_SKILL_CONTENT
+  },
+  "hmy-plan": {
+    name: "hmy-plan",
+    description: "Create a new plan or work on an existing one. Use when asked to plan a feature, execute a plan, review a plan, or given a plan reference.",
+    argumentHint: "[plan name, ID, or topic to plan]",
+    content: HMY_PLAN_CONTENT
+  }
 };
-/**
- * Build a complete skill file with frontmatter and version marker.
- * Optionally substitutes agent identifier/name for agent-specific builds.
- */
-export function buildSkillFile(skillId, agentId) {
-    const skill = SKILL_DEFINITIONS[skillId];
-    if (!skill) {
-        throw new Error(`Unknown skill: ${skillId}`);
-    }
-    let content = skill.content;
-    // Apply agent-specific substitutions
-    if (agentId === "claude") {
-        content = content
-            .replace("Your agent identifier", "claude-code")
-            .replace("Your agent name", "Claude Code");
-    }
-    const frontmatter = `---
+function buildSkillFile(skillId, agentId) {
+  const skill = SKILL_DEFINITIONS[skillId];
+  if (!skill) {
+    throw new Error(`Unknown skill: ${skillId}`);
+  }
+  let content = skill.content;
+  if (agentId === "claude") {
+    content = content.replace("Your agent identifier", "claude-code").replace("Your agent name", "Claude Code");
+  }
+  const frontmatter = `---
 name: ${skill.name}
 description: ${skill.description}
 argument-hint: ${skill.argumentHint}
 ---`;
-    return `${frontmatter}\n\n${content}\n${VERSION_MARKER_PREFIX}${SKILLS_VERSION} -->`;
+  return `${frontmatter}
+
+${content}
+${VERSION_MARKER_PREFIX}${SKILLS_VERSION} -->`;
 }
-/**
- * Parse the skills version from a skill file's content.
- * Returns null if no version marker is found.
- */
 function parseSkillVersion(content) {
-    const match = content.match(/<!-- skills-version:(\d+) -->/);
-    return match ? match[1] : null;
+  const match = content.match(/<!-- skills-version:(\d+) -->/);
+  return match ? match[1] : null;
 }
-/**
- * Find all skill files in a given directory (global or local).
- * Returns an array of { skillId, filePath } for each found skill.
- */
 function findSkillFiles(paths) {
-    const results = [];
-    for (const filePath of paths) {
-        if (!existsSync(filePath))
-            continue;
-        // Determine skill ID from path
-        for (const skillId of Object.keys(SKILL_DEFINITIONS)) {
-            if (filePath.includes(`/${skillId}/`) ||
-                filePath.includes(`/${skillId}.md`)) {
-                results.push({ skillId, filePath });
-                break;
-            }
-        }
+  const results = [];
+  for (const filePath of paths) {
+    if (!existsSync2(filePath))
+      continue;
+    for (const skillId of Object.keys(SKILL_DEFINITIONS)) {
+      if (filePath.includes(`/${skillId}/`) || filePath.includes(`/${skillId}.md`)) {
+        results.push({ skillId, filePath });
+        break;
+      }
     }
-    return results;
+  }
+  return results;
 }
-/**
- * Silently refresh installed skill files if they are outdated.
- * Called at MCP server startup. Non-blocking — errors are caught and logged.
- */
-export async function refreshSkills() {
-    try {
-        const status = areSkillsInstalled();
-        if (!status.installed) {
-            // User hasn't run setup yet — don't install skills
-            return;
-        }
-        // Find skill files from the detected paths
-        const skillFiles = findSkillFiles(status.paths);
-        // Also check for sibling skills in the same directory
-        // e.g., if hmy is installed at ~/.agents/skills/hmy/SKILL.md,
-        // check for hmy-plan at ~/.agents/skills/hmy-plan/SKILL.md
-        if (skillFiles.length > 0) {
-            const samplePath = skillFiles[0].filePath;
-            for (const skillId of Object.keys(SKILL_DEFINITIONS)) {
-                const alreadyFound = skillFiles.some((sf) => sf.skillId === skillId);
-                if (alreadyFound)
-                    continue;
-                // Try to find sibling skill file
-                let siblingPath;
-                if (samplePath.endsWith("SKILL.md")) {
-                    // ~/.agents/skills/hmy/SKILL.md -> ~/.agents/skills/hmy-plan/SKILL.md
-                    const parentDir = dirname(dirname(samplePath));
-                    siblingPath = `${parentDir}/${skillId}/SKILL.md`;
-                }
-                else {
-                    // ~/.claude/skills/hmy.md -> ~/.claude/skills/hmy-plan.md
-                    const parentDir = dirname(samplePath);
-                    siblingPath = `${parentDir}/${skillId}.md`;
-                }
-                if (existsSync(siblingPath)) {
-                    skillFiles.push({ skillId, filePath: siblingPath });
-                }
-            }
-        }
-        if (skillFiles.length === 0) {
-            return;
+async function refreshSkills() {
+  try {
+    const status = areSkillsInstalled();
+    if (!status.installed) {
+      return;
+    }
+    const skillFiles = findSkillFiles(status.paths);
+    if (skillFiles.length > 0) {
+      const samplePath = skillFiles[0].filePath;
+      for (const skillId of Object.keys(SKILL_DEFINITIONS)) {
+        const alreadyFound = skillFiles.some((sf) => sf.skillId === skillId);
+        if (alreadyFound)
+          continue;
+        let siblingPath;
+        if (samplePath.endsWith("SKILL.md")) {
+          const parentDir = dirname(dirname(samplePath));
+          siblingPath = `${parentDir}/${skillId}/SKILL.md`;
+        } else {
+          const parentDir = dirname(samplePath);
+          siblingPath = `${parentDir}/${skillId}.md`;
         }
-        let updated = false;
-        for (const { skillId, filePath } of skillFiles) {
-            try {
-                const currentContent = readFileSync(filePath, "utf-8");
-                const currentVersion = parseSkillVersion(currentContent);
-                // Update if no version marker or version is older
-                if (currentVersion === null ||
-                    Number(currentVersion) < Number(SKILLS_VERSION)) {
-                    const newContent = buildSkillFile(skillId, "claude");
-                    const dir = dirname(filePath);
-                    if (!existsSync(dir)) {
-                        mkdirSync(dir, { recursive: true });
-                    }
-                    writeFileSync(filePath, newContent);
-                    updated = true;
-                }
-            }
-            catch {
-                // Silently skip files we can't read/write
-            }
+        if (existsSync2(siblingPath)) {
+          skillFiles.push({ skillId, filePath: siblingPath });
         }
-        if (updated) {
-            console.error(`Harmony: Updated skills to v${SKILLS_VERSION}`);
+      }
+    }
+    if (skillFiles.length === 0) {
+      return;
+    }
+    let updated = false;
+    for (const { skillId, filePath } of skillFiles) {
+      try {
+        const currentContent = readFileSync2(filePath, "utf-8");
+        const currentVersion = parseSkillVersion(currentContent);
+        if (currentVersion === null || Number(currentVersion) < Number(SKILLS_VERSION)) {
+          const newContent = buildSkillFile(skillId, "claude");
+          const dir = dirname(filePath);
+          if (!existsSync2(dir)) {
+            mkdirSync2(dir, { recursive: true });
+          }
+          writeFileSync2(filePath, newContent);
+          updated = true;
         }
+      } catch {}
     }
-    catch {
-        // Non-blocking — if anything fails, continue silently
+    if (updated) {
+      console.error(`Harmony: Updated skills to v${SKILLS_VERSION}`);
     }
+  } catch {}
 }
+export {
+  refreshSkills,
+  buildSkillFile,
+  SKILL_DEFINITIONS,
+  SKILLS_VERSION,
+  HARMONY_WORKFLOW_PROMPT
+};