@tyvm/knowhow 0.0.129 → 0.0.131

package/ts_build/src/services/SkillsService.js

@@ -0,0 +1,641 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillsService = void 0;
+exports.computeSkillApiHash = computeSkillApiHash;
+exports.computeSkillFolderHash = computeSkillFolderHash;
+exports.parseSkillRef = parseSkillRef;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto_1 = require("crypto");
+const https = __importStar(require("https"));
+const KnowhowClient_1 = require("./KnowhowClient");
+const LOCAL_SKILLS_DIR = ".knowhow/skills";
+const LOCK_FILE_PRIMARY = ".knowhow/skills/skills-lock.json";
+const LOCK_FILE_LEGACY = "skills-lock.json";
+const GLOBAL_SKILLS_DIR = path.join(os.homedir(), ".knowhow", "skills");
+const GLOBAL_LOCK_FILE = path.join(os.homedir(), ".knowhow", "skills", "skills-lock.json");
+const SKILLS_SH_API = "https://skills.sh";
+function createEmptyLock() {
+    return { version: 1, skills: {} };
+}
+function computeSkillApiHash(files) {
+    const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+    const hash = (0, crypto_1.createHash)("sha256");
+    for (const file of sorted) {
+        hash.update(file.path);
+        hash.update(Buffer.from(file.contents, "utf-8"));
+    }
+    return hash.digest("hex");
+}
+function computeSkillFolderHash(skillDir) {
+    const files = [];
+    collectFiles(skillDir, skillDir, files);
+    files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    const hash = (0, crypto_1.createHash)("sha256");
+    for (const file of files) {
+        hash.update(file.relativePath);
+        hash.update(file.content);
+    }
+    return hash.digest("hex");
+}
+function collectFiles(baseDir, currentDir, results) {
+    if (!fs.existsSync(currentDir))
+        return;
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === ".git" || entry.name === "node_modules")
+                continue;
+            collectFiles(baseDir, fullPath, results);
+        }
+        else if (entry.isFile()) {
+            const content = fs.readFileSync(fullPath);
+            const relativePath = path
+                .relative(baseDir, fullPath)
+                .split("\\")
+                .join("/");
+            results.push({ relativePath, content });
+        }
+    }
+}
+function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        https
+            .get(url, { headers: { "User-Agent": "knowhow-cli" } }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                try {
+                    const body = Buffer.concat(chunks).toString("utf-8");
+                    if (res.statusCode && res.statusCode >= 400) {
+                        reject(new Error(`HTTP ${res.statusCode}: ${body}`));
+                        return;
+                    }
+                    resolve(JSON.parse(body));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        })
+            .on("error", reject);
+    });
+}
+function fetchRaw(url) {
+    return new Promise((resolve, reject) => {
+        https
+            .get(url, { headers: { "User-Agent": "knowhow-cli" } }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const body = Buffer.concat(chunks).toString("utf-8");
+                if (res.statusCode && res.statusCode >= 400) {
+                    reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+                    return;
+                }
+                resolve(body);
+            });
+        })
+            .on("error", reject);
+    });
+}
+async function fetchLatestCommitHash(owner, repo, filePath) {
+    try {
+        const url = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/commits?path=${encodeURIComponent(filePath)}&per_page=1`;
+        const commits = await fetchJson(url);
+        if (Array.isArray(commits) && commits.length > 0) {
+            return commits[0].sha;
+        }
+    }
+    catch {
+    }
+    return undefined;
+}
+function parseSkillRef(input, skillNameOverride) {
+    let normalized = input.replace(/\.git$/, "");
+    let skillFromAt;
+    const atIdx = normalized.lastIndexOf("@");
+    if (atIdx > 0 && !normalized.slice(0, atIdx).match(/\/\/$/)) {
+        const beforeAt = normalized.slice(0, atIdx);
+        const afterAt = normalized.slice(atIdx + 1);
+        if (beforeAt.includes("/")) {
+            skillFromAt = afterAt;
+            normalized = beforeAt;
+        }
+    }
+    let owner;
+    let repo;
+    let sourceUrl;
+    const githubMatch = normalized.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/?$/);
+    if (githubMatch) {
+        owner = githubMatch[1];
+        repo = githubMatch[2];
+        sourceUrl = `https://github.com/${owner}/${repo}`;
+    }
+    else {
+        const parts = normalized.split("/");
+        if (parts.length < 2) {
+            throw new Error(`Invalid skill reference "${input}". Expected formats:\n` +
+                `  owner/repo@skill-name\n` +
+                `  https://github.com/owner/repo --skill <name>`);
+        }
+        owner = parts[0];
+        repo = parts[1];
+    }
+    const skill = skillNameOverride ?? skillFromAt;
+    return { owner, repo, skill, sourceUrl };
+}
+class SkillsService {
+    cwd;
+    isGlobal;
+    customInstallDir;
+    client = new KnowhowClient_1.KnowhowSimpleClient();
+    constructor(opts = {}) {
+        this.cwd = opts.cwd ?? process.cwd();
+        this.isGlobal = opts.global ?? false;
+        this.customInstallDir = opts.installDir;
+    }
+    getInstallDir() {
+        if (this.customInstallDir) {
+            return path.isAbsolute(this.customInstallDir)
+                ? this.customInstallDir
+                : path.join(this.cwd, this.customInstallDir);
+        }
+        if (this.isGlobal) {
+            return GLOBAL_SKILLS_DIR;
+        }
+        return path.join(this.cwd, LOCAL_SKILLS_DIR);
+    }
+    getLockPath() {
+        if (this.isGlobal) {
+            return GLOBAL_LOCK_FILE;
+        }
+        if (this.customInstallDir) {
+            return path.join(this.getInstallDir(), "skills-lock.json");
+        }
+        const primary = path.join(this.cwd, LOCK_FILE_PRIMARY);
+        const legacy = path.join(this.cwd, LOCK_FILE_LEGACY);
+        if (!fs.existsSync(primary) && fs.existsSync(legacy)) {
+            return legacy;
+        }
+        return primary;
+    }
+    getLockWritePath() {
+        if (this.isGlobal)
+            return GLOBAL_LOCK_FILE;
+        if (this.customInstallDir) {
+            return path.join(this.getInstallDir(), "skills-lock.json");
+        }
+        return path.join(this.cwd, LOCK_FILE_PRIMARY);
+    }
+    readLock() {
+        const lockPath = this.getLockPath();
+        try {
+            if (fs.existsSync(lockPath)) {
+                const content = fs.readFileSync(lockPath, "utf-8");
+                const parsed = JSON.parse(content);
+                if (typeof parsed.version !== "number" || !parsed.skills) {
+                    return createEmptyLock();
+                }
+                return parsed;
+            }
+        }
+        catch {
+        }
+        return createEmptyLock();
+    }
+    writeLock(lock) {
+        const lockPath = this.getLockWritePath();
+        const dir = path.dirname(lockPath);
+        fs.mkdirSync(dir, { recursive: true });
+        const sortedSkills = {};
+        for (const key of Object.keys(lock.skills).sort()) {
+            sortedSkills[key] = lock.skills[key];
+        }
+        const sorted = { version: lock.version, skills: sortedSkills };
+        fs.writeFileSync(lockPath, JSON.stringify(sorted, null, 2) + "\n", "utf-8");
+    }
+    async fetchSkillFromApi(owner, repo, skill) {
+        const url = `${SKILLS_SH_API}/api/download/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/${encodeURIComponent(skill)}`;
+        return fetchJson(url);
+    }
+    async add(skillRef, skillNameOverride) {
+        const { owner, repo, skill, sourceUrl } = parseSkillRef(skillRef, skillNameOverride);
+        const source = `${owner}/${repo}`;
+        if (!skill) {
+            throw new Error(`Please specify a skill name:\n` +
+                `  knowhow skills add ${source}@<skill-name>\n` +
+                `  knowhow skills add https://github.com/${source} --skill <skill-name>`);
+        }
+        const installDir = this.getInstallDir();
+        const scope = this.isGlobal ? "globally" : "locally";
+        console.log(`📦 Fetching skill "${skill}" from ${source} (installing ${scope})...`);
+        let download;
+        try {
+            download = await this.fetchSkillFromApi(owner, repo, skill);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`Failed to fetch skill "${skill}" from skills.sh API: ${msg}\n` +
+                `Make sure the skill exists at: https://skills.sh/${source}/${skill}`);
+        }
+        if (!download.files || download.files.length === 0) {
+            throw new Error(`No files found for skill "${skill}"`);
+        }
+        const skillInstallDir = path.join(installDir, skill);
+        fs.mkdirSync(skillInstallDir, { recursive: true });
+        for (const file of download.files) {
+            const filePath = path.join(skillInstallDir, file.path);
+            const fileDir = path.dirname(filePath);
+            fs.mkdirSync(fileDir, { recursive: true });
+            fs.writeFileSync(filePath, file.contents, "utf-8");
+        }
+        const computedHash = computeSkillApiHash(download.files);
+        if (download.hash && download.hash !== computedHash) {
+            console.warn(`⚠ Note: API cached hash (${download.hash}) differs from computed hash (${computedHash}). Storing computed hash.`);
+        }
+        const skillPath = `skills/${skill}/SKILL.md`;
+        const commitHash = await fetchLatestCommitHash(owner, repo, skillPath);
+        if (commitHash) {
+            console.log(`📎 Pinned to commit ${commitHash.slice(0, 8)}`);
+        }
+        const lock = this.readLock();
+        lock.skills[skill] = {
+            source,
+            sourceType: "github",
+            skillPath,
+            computedHash,
+            ...(commitHash ? { commitHash } : {}),
+            ...(sourceUrl ? { sourceUrl } : {}),
+        };
+        this.writeLock(lock);
+        console.log(`✅ Installed skill "${skill}" to ${skillInstallDir}`);
+        console.log(`🔒 Updated lock file at ${this.getLockWritePath()}`);
+    }
+    remove(skillName) {
+        const lock = this.readLock();
+        if (!lock.skills[skillName]) {
+            console.warn(`⚠ Skill "${skillName}" not found in lock file.`);
+        }
+        else {
+            delete lock.skills[skillName];
+            this.writeLock(lock);
+            console.log(`🗑  Removed "${skillName}" from lock file.`);
+        }
+        const installDir = path.join(this.getInstallDir(), skillName);
+        if (fs.existsSync(installDir)) {
+            fs.rmSync(installDir, { recursive: true, force: true });
+            console.log(`🗑  Deleted ${installDir}`);
+        }
+        else {
+            console.warn(`⚠ Skill directory not found: ${installDir}`);
+        }
+    }
+    list() {
+        const lock = this.readLock();
+        const skillEntries = Object.entries(lock.skills);
+        if (skillEntries.length === 0) {
+            console.log("No skills installed. Run `knowhow skills add <owner/repo@skill>` to install one.");
+            return;
+        }
+        const installDir = this.getInstallDir();
+        console.log(`Installed skills (${skillEntries.length}):\n`);
+        for (const [name, entry] of skillEntries) {
+            const skillDir = path.join(installDir, name);
+            const installed = fs.existsSync(skillDir);
+            const statusIcon = installed ? "✅" : "❌";
+            console.log(`  ${statusIcon} ${name}`);
+            console.log(`     source: ${entry.source}`);
+            if (entry.skillPath)
+                console.log(`     path:   ${entry.skillPath}`);
+            console.log(`     hash:   ${entry.computedHash}`);
+        }
+    }
+    async install() {
+        const lock = this.readLock();
+        const skillEntries = Object.entries(lock.skills);
+        if (skillEntries.length === 0) {
+            console.log("No skills in lock file. Nothing to install.");
+            return;
+        }
+        const installDir = this.getInstallDir();
+        console.log(`📦 Installing ${skillEntries.length} skill(s) from lock file...\n`);
+        let installed = 0;
+        let skipped = 0;
+        let failed = 0;
+        for (const [name, entry] of skillEntries) {
+            const skillDir = path.join(installDir, name);
+            if (fs.existsSync(skillDir)) {
+                const currentHash = computeSkillFolderHash(skillDir);
+                if (currentHash === entry.computedHash) {
+                    console.log(`  ⏭  ${name} (already up to date)`);
+                    skipped++;
+                    continue;
+                }
+            }
+            const parts = entry.source.split("/");
+            if (parts.length < 2 || entry.sourceType !== "github") {
+                console.warn(`  ⚠ ${name}: unsupported sourceType "${entry.sourceType}", skipping`);
+                failed++;
+                continue;
+            }
+            const [owner, repo] = parts;
+            let skillSlug = name;
+            if (entry.skillPath) {
+                const pathParts = entry.skillPath.split("/");
+                if (pathParts.length >= 2) {
+                    skillSlug = pathParts[pathParts.length - 2];
+                }
+            }
+            try {
+                console.log(`  📥 Installing ${name}...`);
+                const download = await this.fetchSkillFromApi(owner, repo, skillSlug);
+                const files = download.files;
+                fs.mkdirSync(skillDir, { recursive: true });
+                for (const file of files) {
+                    const filePath = path.join(skillDir, file.path);
+                    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                    fs.writeFileSync(filePath, file.contents, "utf-8");
+                }
+                const actualHash = computeSkillApiHash(files);
+                if (actualHash !== entry.computedHash) {
+                    console.warn(`     ⚠ Hash mismatch for ${name}: locked ${entry.computedHash.slice(0, 16)}..., got ${actualHash.slice(0, 16)}...`);
+                }
+                else {
+                    console.log(`     ✓ Hash verified`);
+                }
+                console.log(`  ✅ ${name}`);
+                installed++;
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                console.error(`  ❌ ${name}: ${msg}`);
+                failed++;
+            }
+        }
+        console.log(`\nDone: ${installed} installed, ${skipped} skipped, ${failed} failed.`);
+    }
+    async update(skillNames) {
+        const lock = this.readLock();
+        const toUpdate = skillNames && skillNames.length > 0
+            ? skillNames
+            : Object.keys(lock.skills);
+        if (toUpdate.length === 0) {
+            console.log("No skills to update.");
+            return;
+        }
+        const installDir = this.getInstallDir();
+        console.log(`🔄 Updating ${toUpdate.length} skill(s)...\n`);
+        let updated = 0;
+        let unchanged = 0;
+        let failed = 0;
+        for (const name of toUpdate) {
+            const entry = lock.skills[name];
+            if (!entry) {
+                console.warn(`  ⚠ "${name}" not found in lock file, skipping.`);
+                failed++;
+                continue;
+            }
+            const parts = entry.source.split("/");
+            if (parts.length < 2 || entry.sourceType !== "github") {
+                console.warn(`  ⚠ ${name}: unsupported sourceType, skipping`);
+                failed++;
+                continue;
+            }
+            const [owner, repo] = parts;
+            let skillSlug = name;
+            if (entry.skillPath) {
+                const pathParts = entry.skillPath.split("/");
+                if (pathParts.length >= 2) {
+                    skillSlug = pathParts[pathParts.length - 2];
+                }
+            }
+            try {
+                const download = await this.fetchSkillFromApi(owner, repo, skillSlug);
+                const newHash = computeSkillApiHash(download.files);
+                if (newHash === entry.computedHash) {
+                    console.log(`  ⏭  ${name} (already up to date)`);
+                    unchanged++;
+                    continue;
+                }
+                const skillDir = path.join(installDir, name);
+                fs.mkdirSync(skillDir, { recursive: true });
+                for (const file of download.files) {
+                    const filePath = path.join(skillDir, file.path);
+                    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                    fs.writeFileSync(filePath, file.contents, "utf-8");
+                }
+                lock.skills[name] = { ...entry, computedHash: newHash };
+                console.log(`  ✅ ${name} (updated)`);
+                updated++;
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                console.error(`  ❌ ${name}: ${msg}`);
+                failed++;
+            }
+        }
+        if (updated > 0) {
+            this.writeLock(lock);
+        }
+        console.log(`\nDone: ${updated} updated, ${unchanged} unchanged, ${failed} failed.`);
+    }
+    async upload() {
+        const installDir = this.getInstallDir();
+        if (!fs.existsSync(installDir)) {
+            console.error(`No skills directory found at ${installDir}. Run 'knowhow skills add <ref>' first.`);
+            return;
+        }
+        const entries = fs.readdirSync(installDir, { withFileTypes: true });
+        const skillDirs = entries.filter((e) => e.isDirectory());
+        if (skillDirs.length === 0) {
+            console.log("No skill directories found. Nothing to upload.");
+            return;
+        }
+        let uploaded = 0;
+        let failed = 0;
+        for (const dir of skillDirs) {
+            const skillFile = path.join(installDir, dir.name, "SKILL.md");
+            if (!fs.existsSync(skillFile)) {
+                console.warn(`  ⚠ ${dir.name}: no SKILL.md found, skipping.`);
+                continue;
+            }
+            try {
+                const raw = fs.readFileSync(skillFile, "utf-8");
+                const behavior = this.parseSkillMd(raw, dir.name);
+                const payload = {
+                    ...behavior,
+                    isSkill: true,
+                };
+                if (behavior.id) {
+                    await this.client.updateOrgBehavior(behavior.id, payload);
+                    console.log(`  📝 Updated: ${behavior.name} (${behavior.id})`);
+                }
+                else {
+                    const result = await this.client.createOrgBehavior(payload);
+                    const created = result.data;
+                    if (created.id) {
+                        const withId = this.injectIdIntoSkillMd(raw, created.id);
+                        fs.writeFileSync(skillFile, withId, "utf-8");
+                        console.log(`  ✨ Created: ${behavior.name} (id: ${created.id})`);
+                    }
+                    else {
+                        console.log(`  ✨ Created: ${behavior.name}`);
+                    }
+                }
+                uploaded++;
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                console.error(`  ❌ ${dir.name}: ${msg}`);
+                failed++;
+            }
+        }
+        console.log(`\nUploaded ${uploaded} skill(s). Failed: ${failed}.`);
+    }
+    async download() {
+        const installDir = this.getInstallDir();
+        const result = await this.client.getOrgSkills(false);
+        const skills = result.data;
+        if (skills.length === 0) {
+            console.log("No skills found on backend.");
+            return;
+        }
+        let created = 0;
+        let updated = 0;
+        let unchanged = 0;
+        for (const skill of skills) {
+            const name = (skill.name || "unnamed")
+                .toLowerCase()
+                .replace(/[^a-z0-9-]+/g, "-");
+            const skillDir = path.join(installDir, name);
+            fs.mkdirSync(skillDir, { recursive: true });
+            const skillFile = path.join(skillDir, "SKILL.md");
+            const content = this.serializeSkillMd(skill);
+            const hash = (s) => (0, crypto_1.createHash)("sha256").update(s).digest("hex");
+            if (!fs.existsSync(skillFile)) {
+                fs.writeFileSync(skillFile, content, "utf-8");
+                console.log(`  ✨ Created: ${skillFile}`);
+                created++;
+            }
+            else {
+                const existing = fs.readFileSync(skillFile, "utf-8");
+                if (hash(existing) !== hash(content)) {
+                    fs.writeFileSync(skillFile, content, "utf-8");
+                    console.log(`  📝 Updated: ${skillFile}`);
+                    updated++;
+                }
+                else {
+                    unchanged++;
+                }
+            }
+        }
+        console.log(`\nSync complete: ${created} created, ${updated} updated, ${unchanged} unchanged → ${installDir}/`);
+    }
+    parseSkillMd(content, fallbackName) {
+        const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+        if (!match) {
+            return { name: fallbackName, description: "", instructions: content.trim(), isSkill: true };
+        }
+        const meta = {};
+        for (const line of match[1].split("\n")) {
+            const colonIdx = line.indexOf(":");
+            if (colonIdx > 0) {
+                const key = line.slice(0, colonIdx).trim();
+                const val = line.slice(colonIdx + 1).trim();
+                meta[key] = val;
+            }
+        }
+        return {
+            id: meta.id || undefined,
+            name: meta.name || fallbackName,
+            description: meta.description || "",
+            instructions: match[2].trim(),
+            textTrigger: meta.textTrigger || undefined,
+            semanticTriggerText: meta.semanticTriggerText || undefined,
+            model: meta.model || undefined,
+            mcpServers: meta.mcpServers || undefined,
+            tools: meta.tools || undefined,
+            embeddings: meta.embeddings || undefined,
+            isSkill: true,
+            isPublic: meta.isPublic === "true",
+        };
+    }
+    serializeSkillMd(skill) {
+        const lines = ["---"];
+        lines.push(`name: ${skill.name || ""}`);
+        lines.push(`description: ${skill.description || ""}`);
+        if (skill.model)
+            lines.push(`model: ${skill.model}`);
+        if (skill.textTrigger)
+            lines.push(`textTrigger: ${skill.textTrigger}`);
+        if (skill.semanticTriggerText)
+            lines.push(`semanticTriggerText: ${skill.semanticTriggerText}`);
+        if (skill.mcpServers)
+            lines.push(`mcpServers: ${skill.mcpServers}`);
+        if (skill.tools)
+            lines.push(`tools: ${skill.tools}`);
+        if (skill.embeddings)
+            lines.push(`embeddings: ${skill.embeddings}`);
+        if (skill.isPublic !== undefined)
+            lines.push(`isPublic: ${skill.isPublic}`);
+        if (skill.id)
+            lines.push(`id: ${skill.id}`);
+        lines.push("---");
+        lines.push("");
+        lines.push((skill.instructions || "").trim());
+        lines.push("");
+        return lines.join("\n");
+    }
+    injectIdIntoSkillMd(content, id) {
+        const match = content.match(/^(---\n[\s\S]*?\n---\n?)([\s\S]*)$/);
+        if (!match)
+            return content;
+        let frontmatter = match[1];
+        const body = match[2];
+        if (/^id:/m.test(frontmatter)) {
+            frontmatter = frontmatter.replace(/^id:.*$/m, `id: ${id}`);
+        }
+        else {
+            frontmatter = frontmatter.replace(/\n---\n?$/, `\nid: ${id}\n---\n`);
+        }
+        return frontmatter + body;
+    }
+}
+exports.SkillsService = SkillsService;
+//# sourceMappingURL=SkillsService.js.map