pikiloom 0.4.40 → 0.4.41

package/packages/kernel/dist/workspace/skills.js

@@ -0,0 +1,173 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const DEFAULT_AGENT_SKILL_DIRS = ['.claude/skills', '.agents/skills'];
+function parseSkillMeta(content) {
+    let label = null;
+    let description = null;
+    let mcpRequires;
+    const fm = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (fm) {
+        const lm = fm[1].match(/^label:\s*(.+)/m);
+        if (lm)
+            label = lm[1].trim();
+        const dm = fm[1].match(/^description:\s*(.+)/m);
+        if (dm)
+            description = dm[1].trim();
+        const mr = fm[1].match(/^mcp_requires:\s*\n((?:\s+-\s+.+\n?)+)/m);
+        if (mr) {
+            mcpRequires = mr[1].split('\n').map(l => l.replace(/^\s*-\s*/, '').replace(/["']/g, '').trim()).filter(Boolean);
+        }
+    }
+    if (!label) {
+        const hm = content.match(/^#\s+(.+)$/m);
+        if (hm)
+            label = hm[1].trim();
+    }
+    return { label, description, mcpRequires };
+}
+function realPathOrNull(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return null;
+    }
+}
+/** Make `linkPath` a symlink to `targetDir` (idempotent; replaces a stale link/dir). */
+export function ensureDirSymlink(linkPath, targetDir) {
+    const desiredTarget = path.relative(path.dirname(linkPath), targetDir) || '.';
+    try {
+        const stat = fs.lstatSync(linkPath);
+        if (stat.isSymbolicLink()) {
+            const currentTarget = fs.readlinkSync(linkPath);
+            const currentReal = realPathOrNull(path.resolve(path.dirname(linkPath), currentTarget));
+            const desiredReal = realPathOrNull(targetDir);
+            if (currentTarget === desiredTarget || (currentReal && desiredReal && currentReal === desiredReal))
+                return;
+            fs.unlinkSync(linkPath);
+        }
+        else {
+            fs.rmSync(linkPath, { recursive: true, force: true });
+        }
+    }
+    catch { /* nothing there yet */ }
+    fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+    try {
+        fs.symlinkSync(desiredTarget, linkPath, process.platform === 'win32' ? 'junction' : 'dir');
+    }
+    catch (err) {
+        if (err?.code !== 'EEXIST' || fs.readlinkSync(linkPath) !== desiredTarget)
+            throw err;
+    }
+}
+function discoverSkillsFromDir(dir, scope, seen) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir).sort((a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' }));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of entries) {
+        if (!name || seen.has(name))
+            continue;
+        const skillDir = path.join(dir, name);
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        try {
+            if (!fs.statSync(skillDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        try {
+            if (!fs.statSync(skillFile).isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        let meta = { label: null, description: null };
+        try {
+            meta = parseSkillMeta(fs.readFileSync(skillFile, 'utf8'));
+        }
+        catch { /* keep defaults */ }
+        out.push({ name, label: meta.label, description: meta.description, scope, path: skillDir, mcpRequires: meta.mcpRequires });
+        seen.add(name);
+    }
+    return out;
+}
+export class SkillsManager {
+    paths;
+    agentSkillDirs;
+    log;
+    constructor(opts) {
+        this.paths = opts.paths;
+        this.agentSkillDirs = opts.agentSkillDirs?.length ? opts.agentSkillDirs : DEFAULT_AGENT_SKILL_DIRS;
+        this.log = opts.log;
+    }
+    /** The canonical skills dir for a scope, e.g. <workdir>/.pikiloom/skills or ~/.pikiloom/skills. */
+    canonicalDir(scope, workdir) {
+        return this.paths.skillsDir(scope, workdir);
+    }
+    /** Absolute paths of the per-agent skill dirs that link to the canonical dir for a scope. */
+    agentLinkPaths(scope, workdir) {
+        const base = this.paths.agentHome(scope, workdir);
+        return this.agentSkillDirs.map(rel => path.join(base, rel));
+    }
+    /** Ensure the canonical dir exists and each agent skills dir symlinks to it. */
+    ensureLinks(scope, workdir) {
+        const canonical = this.canonicalDir(scope, workdir);
+        fs.mkdirSync(canonical, { recursive: true });
+        for (const link of this.agentLinkPaths(scope, workdir)) {
+            try {
+                ensureDirSymlink(link, canonical);
+            }
+            catch (e) {
+                this.log?.(`[skills] link ${link} -> ${canonical} failed: ${e?.message || e}`);
+            }
+        }
+    }
+    /** List skills. scope 'all' (default) = workspace (if workdir) then global, project wins on name clash. */
+    list(opts = {}) {
+        const scope = opts.scope ?? 'all';
+        const seen = new Set();
+        const out = [];
+        if ((scope === 'workspace' || scope === 'all') && opts.workdir) {
+            out.push(...discoverSkillsFromDir(this.paths.skillsDir('workspace', opts.workdir), 'workspace', seen));
+        }
+        if (scope === 'global' || scope === 'all') {
+            out.push(...discoverSkillsFromDir(this.paths.skillsDir('global'), 'global', seen));
+        }
+        return out;
+    }
+    /** Search installable skills on the npm registry (best-effort; [] on failure). */
+    async search(query, limit = 20) {
+        const q = (query || '').trim();
+        const text = encodeURIComponent(`agent skill ${q}`.trim());
+        const url = `https://registry.npmjs.org/-/v1/search?text=${text}&size=${Math.max(1, Math.min(50, limit))}`;
+        try {
+            const res = await fetch(url, { headers: { accept: 'application/json' } });
+            if (!res.ok)
+                return [];
+            const data = await res.json();
+            const objects = Array.isArray(data?.objects) ? data.objects : [];
+            return objects.map((o) => {
+                const pkg = o?.package ?? {};
+                return {
+                    name: String(pkg.name ?? ''),
+                    description: pkg.description ?? null,
+                    source: 'npm',
+                    author: pkg.publisher?.username ?? pkg.author?.name ?? null,
+                    homepage: pkg.links?.homepage ?? pkg.links?.npm ?? null,
+                    version: pkg.version ?? null,
+                };
+            }).filter(s => s.name);
+        }
+        catch (e) {
+            this.log?.(`[skills] search failed: ${e?.message || e}`);
+            return [];
+        }
+    }
+}