heymark 2.0.0 → 2.0.1

package/src/skill-repo/config-file.js

@@ -0,0 +1,87 @@
+const fs = require("fs");
+const path = require("path");
+const { HEYMARK, SKILL_REPO_DEFAULT_BRANCH } = require("@/skill-repo/constants");
+
+function getConfigFilePath(cwd) {
+    return path.join(cwd, HEYMARK.DIR, HEYMARK.CONFIG_FILE);
+}
+
+function parseRawConfig(rawConfig) {
+    if (!rawConfig || typeof rawConfig !== "object") {
+        return null;
+    }
+
+    const raw = rawConfig;
+
+    const repoUrl =
+        typeof raw.repoUrl === "string" && raw.repoUrl.trim()
+            ? raw.repoUrl.trim()
+            : typeof raw.skillSource === "string" && raw.skillSource.trim()
+              ? raw.skillSource.trim()
+              : typeof raw.rulesSource === "string" && raw.rulesSource.trim()
+                ? raw.rulesSource.trim()
+                : "";
+
+    if (!repoUrl) {
+        return null;
+    }
+
+    const branch =
+        typeof raw.branch === "string" && raw.branch.trim()
+            ? raw.branch.trim()
+            : SKILL_REPO_DEFAULT_BRANCH;
+
+    const folder =
+        typeof raw.folder === "string"
+            ? raw.folder.trim()
+            : typeof raw.skillSourceDir === "string"
+              ? raw.skillSourceDir.trim()
+              : typeof raw.rulesSourceDir === "string"
+                ? raw.rulesSourceDir.trim()
+                : "";
+
+    return { repoUrl, branch, folder };
+}
+
+function writeConfig(cwd, config) {
+    const dir = path.join(cwd, HEYMARK.DIR);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const data = parseRawConfig(config);
+    if (!data) {
+        throw new Error("Invalid config");
+    }
+
+    const filePath = getConfigFilePath(cwd);
+    const payload = {
+        repoUrl: data.repoUrl,
+        branch: data.branch || SKILL_REPO_DEFAULT_BRANCH,
+    };
+    if (data.folder) {
+        payload.folder = data.folder;
+    }
+
+    fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+    return filePath;
+}
+
+function readConfig(cwd) {
+    const filePath = getConfigFilePath(cwd);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+
+    try {
+        const raw = fs.readFileSync(filePath, "utf8");
+        return parseRawConfig(JSON.parse(raw));
+    } catch {
+        return null;
+    }
+}
+
+module.exports = {
+    writeConfig,
+    readConfig,
+};

package/src/skill-repo/constants.js

@@ -0,0 +1,14 @@
+const HEYMARK = {
+    DIR: ".heymark",
+    CONFIG_FILE: "config.json",
+    CACHE_DIR: "cache",
+};
+
+const SKILL_FILE_EXTENSION = ".md";
+const SKILL_REPO_DEFAULT_BRANCH = "main";
+
+module.exports = {
+    HEYMARK,
+    SKILL_FILE_EXTENSION,
+    SKILL_REPO_DEFAULT_BRANCH,
+};

package/src/skill-repo/skill-file-parser.js

@@ -0,0 +1,79 @@
+const fs = require("fs");
+const path = require("path");
+const { SKILL_FILE_EXTENSION } = require("@/skill-repo/constants");
+
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]+?)\r?\n---\r?\n?([\s\S]*)$/;
+
+function parseFrontmatter(content) {
+    const match = content.match(FRONTMATTER_REGEX);
+    if (!match) {
+        return { metadata: {}, body: content.trim() };
+    }
+
+    const [, metadataBlock, body] = match;
+
+    const metadata = {};
+    metadataBlock.split(/\r?\n/).forEach((line) => {
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex === -1) return;
+
+        const key = line.slice(0, separatorIndex).trim();
+        let value = line.slice(separatorIndex + 1).trim();
+
+        if (
+            (value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))
+        ) {
+            value = value.slice(1, -1);
+        }
+
+        if (value === "true") metadata[key] = true;
+        else if (value === "false") metadata[key] = false;
+        else metadata[key] = value;
+    });
+
+    return { metadata, body: body.trim() };
+}
+
+function readSkillFile(skillsDir, fileName) {
+    const filePath = path.join(skillsDir, fileName);
+    const raw = fs.readFileSync(filePath, "utf8");
+    const { metadata, body } = parseFrontmatter(raw);
+    const baseName = path.basename(fileName, SKILL_FILE_EXTENSION);
+
+    return {
+        fileName,
+        name: typeof metadata.name === "string" && metadata.name ? metadata.name : baseName,
+        description:
+            typeof metadata.description === "string" && metadata.description
+                ? metadata.description
+                : baseName,
+        globs: typeof metadata.globs === "string" ? metadata.globs : "",
+        alwaysApply: metadata.alwaysApply === true,
+        metadata,
+        body,
+    };
+}
+
+function readSkillFiles(skillsDir) {
+    if (!fs.existsSync(skillsDir)) {
+        console.error(`[Error] Skills folder not found: ${skillsDir}`);
+        process.exit(1);
+    }
+
+    const files = fs
+        .readdirSync(skillsDir)
+        .filter((fileName) => fileName.endsWith(SKILL_FILE_EXTENSION))
+        .sort();
+
+    if (files.length === 0) {
+        console.error(`[Error] No .md files in: ${skillsDir}`);
+        process.exit(1);
+    }
+
+    return files.map((fileName) => readSkillFile(skillsDir, fileName));
+}
+
+module.exports = {
+    readSkillFiles,
+};

package/src/tools/antigravity/index.js

@@ -0,0 +1,33 @@
+const { ANTIGRAVITY } = require("@/tools/constants");
+const { generate, clean } = require("@/tools/skill-per-folder");
+
+function createContent(skill) {
+    const frontmatterLines = [
+        "---",
+        `name: ${skill.name}`,
+        `description: "${skill.description}"`,
+        "---",
+    ];
+
+    return `${frontmatterLines.join("\n")}\n\n${skill.body}\n`;
+}
+
+module.exports = {
+    key: ANTIGRAVITY.KEY,
+    name: ANTIGRAVITY.NAME,
+    output: ANTIGRAVITY.OUTPUT_PATTERN,
+
+    generate(skills, cwd) {
+        return generate({
+            cwd,
+            dir: ANTIGRAVITY.SKILLS_DIR,
+            fileName: ANTIGRAVITY.SKILL_FILE_NAME,
+            skills,
+            createContent,
+        });
+    },
+
+    clean(skillNames, cwd) {
+        return clean(cwd, ANTIGRAVITY.SKILLS_DIR);
+    },
+};

package/src/tools/claude-code/index.js

@@ -0,0 +1,33 @@
+const { CLAUDE_CODE } = require("@/tools/constants");
+const { generate, clean } = require("@/tools/skill-per-folder");
+
+function createContent(skill) {
+    const frontmatterLines = [
+        "---",
+        `name: ${skill.name}`,
+        `description: "${skill.description}"`,
+        "---",
+    ];
+
+    return `${frontmatterLines.join("\n")}\n\n${skill.body}\n`;
+}
+
+module.exports = {
+    key: CLAUDE_CODE.KEY,
+    name: CLAUDE_CODE.NAME,
+    output: CLAUDE_CODE.OUTPUT_PATTERN,
+
+    generate(skills, cwd) {
+        return generate({
+            cwd,
+            dir: CLAUDE_CODE.SKILLS_DIR,
+            fileName: CLAUDE_CODE.SKILL_FILE_NAME,
+            skills,
+            createContent,
+        });
+    },
+
+    clean(skillNames, cwd) {
+        return clean(cwd, CLAUDE_CODE.SKILLS_DIR);
+    },
+};

package/src/tools/codex/index.js

@@ -0,0 +1,33 @@
+const { CODEX } = require("@/tools/constants");
+const { generate, clean } = require("@/tools/skill-per-folder");
+
+function createContent(skill) {
+    const frontmatterLines = [
+        "---",
+        `name: ${skill.name}`,
+        `description: "${skill.description}"`,
+        "---",
+    ];
+
+    return `${frontmatterLines.join("\n")}\n\n${skill.body}\n`;
+}
+
+module.exports = {
+    key: CODEX.KEY,
+    name: CODEX.NAME,
+    output: CODEX.OUTPUT_PATTERN,
+
+    generate(skills, cwd) {
+        return generate({
+            cwd,
+            dir: CODEX.SKILLS_DIR,
+            fileName: CODEX.SKILL_FILE_NAME,
+            skills,
+            createContent,
+        });
+    },
+
+    clean(skillNames, cwd) {
+        return clean(cwd, CODEX.SKILLS_DIR);
+    },
+};

package/src/tools/constants.js

@@ -0,0 +1,44 @@
+const path = require("path");
+
+const ANTIGRAVITY = {
+    KEY: "antigravity",
+    NAME: "Antigravity",
+    SKILLS_DIR: path.join(".agent", "skills"),
+    SKILL_FILE_NAME: "SKILL.md",
+    OUTPUT_PATTERN: ".agent/skills/*/SKILL.md",
+};
+
+const CLAUDE_CODE = {
+    KEY: "claude-code",
+    NAME: "Claude Code",
+    SKILLS_DIR: path.join(".claude", "skills"),
+    SKILL_FILE_NAME: "SKILL.md",
+    OUTPUT_PATTERN: ".claude/skills/*/SKILL.md",
+};
+
+const CODEX = {
+    KEY: "codex",
+    NAME: "Codex",
+    SKILLS_DIR: path.join(".agents", "skills"),
+    SKILL_FILE_NAME: "SKILL.md",
+    OUTPUT_PATTERN: ".agents/skills/*/SKILL.md",
+};
+
+const COPILOT = {
+    KEY: "copilot",
+    NAME: "Copilot",
+    INSTRUCTIONS_DIR: path.join(".github", "instructions"),
+    FILE_SUFFIX: ".instructions.md",
+    DEFAULT_GLOB: "**",
+    OUTPUT_PATTERN: ".github/instructions/*.instructions.md",
+};
+
+const CURSOR = {
+    KEY: "cursor",
+    NAME: "Cursor",
+    SKILLS_DIR: path.join(".cursor", "rules"),
+    FILE_SUFFIX: ".mdc",
+    OUTPUT_PATTERN: ".cursor/rules/*.mdc",
+};
+
+module.exports = { ANTIGRAVITY, CLAUDE_CODE, CODEX, COPILOT, CURSOR };

package/src/tools/copilot/index.js

@@ -0,0 +1,40 @@
+const { COPILOT } = require("@/tools/constants");
+const { generate, clean } = require("@/tools/skill-per-file");
+
+function getFileName(skill) {
+    return `${skill.name}${COPILOT.FILE_SUFFIX}`;
+}
+
+function createContent(skill) {
+    const globs = skill.globs
+        ? skill.globs
+              .split(",")
+              .map((g) => g.trim())
+              .filter(Boolean)
+        : [];
+    const applyToLines = (globs.length > 0 ? globs : [COPILOT.DEFAULT_GLOB])
+        .map((glob) => `  - "${glob}"`)
+        .join("\n");
+    const header = `applyTo:\n${applyToLines}\n---`;
+    return `${header}\n\n${skill.body}\n`;
+}
+
+module.exports = {
+    key: COPILOT.KEY,
+    name: COPILOT.NAME,
+    output: COPILOT.OUTPUT_PATTERN,
+
+    generate(skills, cwd) {
+        return generate({
+            cwd,
+            dir: COPILOT.INSTRUCTIONS_DIR,
+            skills,
+            getFileName,
+            createContent,
+        });
+    },
+
+    clean(skillNames, cwd) {
+        return clean(cwd, COPILOT.INSTRUCTIONS_DIR);
+    },
+};

package/src/tools/cursor/index.js

@@ -0,0 +1,39 @@
+const { CURSOR } = require("@/tools/constants");
+const { generate, clean } = require("@/tools/skill-per-file");
+
+function getFileName(skill) {
+    return `${skill.name}${CURSOR.FILE_SUFFIX}`;
+}
+
+function createContent(skill) {
+    const frontmatterLines = ["---", `description: "${skill.description}"`];
+
+    if (skill.globs) {
+        frontmatterLines.push(`globs: "${skill.globs}"`);
+    }
+
+    frontmatterLines.push(`alwaysApply: ${skill.alwaysApply}`);
+    frontmatterLines.push("---");
+
+    return `${frontmatterLines.join("\n")}\n\n${skill.body}\n`;
+}
+
+module.exports = {
+    key: CURSOR.KEY,
+    name: CURSOR.NAME,
+    output: CURSOR.OUTPUT_PATTERN,
+
+    generate(skills, cwd) {
+        return generate({
+            cwd,
+            dir: CURSOR.SKILLS_DIR,
+            skills,
+            getFileName,
+            createContent,
+        });
+    },
+
+    clean(skillNames, cwd) {
+        return clean(cwd, CURSOR.SKILLS_DIR);
+    },
+};

package/src/tools/loader.js

@@ -0,0 +1,17 @@
+const fs = require("fs");
+const path = require("path");
+
+const TOOLS_DIR = path.join(__dirname);
+
+function loadTools() {
+    const tools = fs
+        .readdirSync(TOOLS_DIR)
+        .filter((name) => fs.statSync(path.join(TOOLS_DIR, name)).isDirectory())
+        .map((name) => require(path.join(TOOLS_DIR, name)));
+
+    return Object.fromEntries(tools.map((tool) => [tool.key, tool]));
+}
+
+module.exports = {
+    loadTools,
+};

package/src/tools/skill-per-file.js

@@ -0,0 +1,29 @@
+const fs = require("fs");
+const path = require("path");
+
+function generate({ cwd, dir, skills, getFileName, createContent }) {
+    const destDir = path.join(cwd, dir);
+    fs.mkdirSync(destDir, { recursive: true });
+
+    for (const skill of skills) {
+        const filePath = path.join(destDir, getFileName(skill));
+        fs.writeFileSync(filePath, createContent(skill), "utf8");
+    }
+
+    return skills.length;
+}
+
+function clean(cwd, dir) {
+    const targetPath = path.join(cwd, dir);
+    if (!fs.existsSync(targetPath)) {
+        return [];
+    }
+
+    fs.rmSync(targetPath, { recursive: true, force: true });
+    return [dir];
+}
+
+module.exports = {
+    generate,
+    clean,
+};

package/src/tools/skill-per-folder.js

@@ -0,0 +1,18 @@
+const fs = require("fs");
+const path = require("path");
+const { clean } = require("@/tools/skill-per-file");
+
+function generate({ cwd, dir, fileName, skills, createContent }) {
+    for (const skill of skills) {
+        const skillDir = path.join(cwd, dir, skill.name);
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, fileName), createContent(skill), "utf8");
+    }
+
+    return skills.length;
+}
+
+module.exports = {
+    generate,
+    clean,
+};