pikiloop 0.4.0

package/dist/agent/skill-installer.js

@@ -0,0 +1,160 @@
+/**
+ * Skill installer — wrapper around `npx skills` CLI.
+ *
+ * Skills are installed via the community-standard `npx skills add` command.
+ * Global skills go to ~/.pikiloop/skills/, project skills to <workdir>/.pikiloop/skills/.
+ *
+ * The upstream CLI doesn't recognize `pikiloop` as an agent, so we install with
+ * `--agent claude-code` (the driver pikiloop runs by default) and rely on
+ * ~/.claude/skills → ~/.pikiloop/skills being symlinked to the same directory.
+ */
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { STATE_DIR_NAME } from '../core/constants.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const GLOBAL_SKILLS_DIR = path.join(os.homedir(), STATE_DIR_NAME, 'skills');
+const INSTALL_TIMEOUT_MS = 60_000;
+const REMOVE_TIMEOUT_MS = 10_000;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Make sure the global skills directory exists, and that the agent-specific
+ * dirs that the upstream skills CLI writes to (`~/.claude/skills`,
+ * `~/.agents/skills`) resolve back to it. This is what lets us install with
+ * `--agent claude-code` and still read the results from `~/.pikiloop/skills`.
+ */
+function ensureGlobalSkillsDir() {
+    fs.mkdirSync(GLOBAL_SKILLS_DIR, { recursive: true });
+    for (const linkDir of [
+        path.join(os.homedir(), '.claude', 'skills'),
+        path.join(os.homedir(), '.agents', 'skills'),
+    ]) {
+        try {
+            const stat = fs.lstatSync(linkDir);
+            if (stat.isSymbolicLink()) {
+                const real = fs.realpathSync(linkDir);
+                if (real === fs.realpathSync(GLOBAL_SKILLS_DIR))
+                    continue;
+            }
+            // Existing dir/link doesn't match — leave it alone rather than destroy user data.
+            continue;
+        }
+        catch {
+            try {
+                fs.mkdirSync(path.dirname(linkDir), { recursive: true });
+                fs.symlinkSync(GLOBAL_SKILLS_DIR, linkDir, 'dir');
+            }
+            catch { /* best effort */ }
+        }
+    }
+}
+function runNpx(args, cwd, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = execFile('npx', args, {
+            cwd,
+            timeout: timeoutMs,
+            env: { ...process.env, NODE_NO_WARNINGS: '1' },
+            shell: process.platform === 'win32',
+        }, (error, stdout, stderr) => {
+            resolve({
+                ok: !error,
+                stdout: stdout?.toString() || '',
+                stderr: stderr?.toString() || '',
+            });
+        });
+        // Prevent child from keeping parent alive
+        child.unref?.();
+    });
+}
+// ---------------------------------------------------------------------------
+// Install
+// ---------------------------------------------------------------------------
+/**
+ * Install a skill from a source (GitHub owner/repo, URL, or local path).
+ *
+ * Uses `npx skills add <source>` with appropriate flags.
+ */
+export async function installSkill(source, opts = {}) {
+    const { global: isGlobal, skill, workdir } = opts;
+    if (!isGlobal && !workdir) {
+        return { ok: false, error: 'workdir is required for project-scoped skill installation' };
+    }
+    const cwd = isGlobal ? os.homedir() : workdir;
+    const args = ['-y', 'skills', 'add', source, '--yes', '--agent', 'claude-code'];
+    if (isGlobal) {
+        args.push('-g');
+        ensureGlobalSkillsDir();
+    }
+    if (skill) {
+        args.push('-s', skill);
+    }
+    const result = await runNpx(args, cwd, INSTALL_TIMEOUT_MS);
+    if (!result.ok) {
+        const errorMsg = result.stderr.trim().split('\n').pop()?.trim() || 'installation failed';
+        return { ok: false, error: errorMsg, output: result.stdout + result.stderr };
+    }
+    return { ok: true, output: result.stdout };
+}
+// ---------------------------------------------------------------------------
+// Remove
+// ---------------------------------------------------------------------------
+/**
+ * Remove an installed skill by name.
+ * Deletes the skill directory from the appropriate location.
+ */
+export function removeSkill(skillName, opts = {}) {
+    const { global: isGlobal, workdir } = opts;
+    if (!isGlobal && !workdir) {
+        return { ok: false, error: 'workdir is required for project-scoped skill removal' };
+    }
+    // Security: prevent path traversal — skill name must be a plain directory name
+    const sanitized = path.basename(skillName);
+    if (!sanitized || sanitized === '.' || sanitized === '..' || sanitized !== skillName) {
+        return { ok: false, error: 'invalid skill name' };
+    }
+    const parentDir = isGlobal
+        ? GLOBAL_SKILLS_DIR
+        : path.join(workdir, STATE_DIR_NAME, 'skills');
+    const skillDir = path.join(parentDir, sanitized);
+    // Double-check the resolved path is inside the expected parent
+    const realParent = path.resolve(parentDir);
+    const realSkill = path.resolve(skillDir);
+    if (!realSkill.startsWith(realParent + path.sep)) {
+        return { ok: false, error: 'invalid skill path' };
+    }
+    try {
+        if (!fs.existsSync(skillDir)) {
+            return { ok: false, error: `skill "${sanitized}" not found` };
+        }
+        fs.rmSync(skillDir, { recursive: true, force: true });
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: e?.message || 'removal failed' };
+    }
+}
+// ---------------------------------------------------------------------------
+// List installed (enhanced)
+// ---------------------------------------------------------------------------
+export function getGlobalSkillsDir() {
+    return GLOBAL_SKILLS_DIR;
+}
+// ---------------------------------------------------------------------------
+// Check for updates
+// ---------------------------------------------------------------------------
+export async function checkSkillUpdates(opts = {}) {
+    const cwd = opts.global ? os.homedir() : (opts.workdir || process.cwd());
+    const args = ['-y', 'skills', 'check'];
+    if (opts.global)
+        args.push('-g');
+    return runNpx(args, cwd, INSTALL_TIMEOUT_MS).then(r => ({
+        ok: r.ok,
+        output: r.stdout,
+        error: r.ok ? undefined : r.stderr,
+    }));
+}

package/dist/agent/skills.js

@@ -0,0 +1,257 @@
+/**
+ * Project skill discovery from .pikiloop/skills and .claude/commands.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { STATE_DIR_NAME, LEGACY_STATE_DIR_NAME } from '../core/constants.js';
+function resolveProjectSkillRoots(workdir) {
+    return {
+        canonicalRoot: path.join(workdir, STATE_DIR_NAME, 'skills'),
+        legacyRoot: path.join(workdir, LEGACY_STATE_DIR_NAME, 'skills'),
+        claudeRoot: path.join(workdir, '.claude', 'skills'),
+        agentsRoot: path.join(workdir, '.agents', 'skills'),
+    };
+}
+function resolveSkillFile(root, skillName) {
+    return path.join(root, skillName, 'SKILL.md');
+}
+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();
+        // Parse mcp_requires as YAML list
+        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 hasFile(filePath) {
+    try {
+        return fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function hasDir(dirPath) {
+    try {
+        return fs.statSync(dirPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function readSortedDir(dirPath) {
+    try {
+        return fs.readdirSync(dirPath).sort((a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' }));
+    }
+    catch {
+        return [];
+    }
+}
+function listRelativeFiles(dirPath, prefix = '') {
+    const files = [];
+    for (const entry of readSortedDir(dirPath)) {
+        const abs = path.join(dirPath, entry);
+        const rel = prefix ? path.join(prefix, entry) : entry;
+        let stat;
+        try {
+            stat = fs.statSync(abs);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory())
+            files.push(...listRelativeFiles(abs, rel));
+        else if (stat.isFile())
+            files.push(rel);
+    }
+    return files;
+}
+function realPathOrNull(filePath) {
+    try {
+        return fs.realpathSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+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.rmSync(linkPath, { recursive: true, force: true });
+    }
+    catch { }
+    fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+    fs.symlinkSync(desiredTarget, linkPath, process.platform === 'win32' ? 'junction' : 'dir');
+}
+function copyMergedTree(sourceRoot, targetRoot, opts = {}) {
+    for (const relPath of listRelativeFiles(sourceRoot)) {
+        const sourcePath = path.join(sourceRoot, relPath);
+        const targetPath = path.join(targetRoot, relPath);
+        if (hasFile(targetPath)) {
+            opts.log?.(`skills merge skipped existing file: ${relPath}`);
+            continue;
+        }
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+}
+export function initializeProjectSkills(workdir, opts = {}) {
+    const { canonicalRoot, claudeRoot, agentsRoot } = resolveProjectSkillRoots(workdir);
+    fs.mkdirSync(canonicalRoot, { recursive: true });
+    const canonicalReal = realPathOrNull(canonicalRoot);
+    for (const legacyRoot of [claudeRoot, agentsRoot]) {
+        if (!hasDir(legacyRoot))
+            continue;
+        const legacyReal = realPathOrNull(legacyRoot);
+        if (legacyReal && canonicalReal && legacyReal === canonicalReal)
+            continue;
+        copyMergedTree(legacyRoot, canonicalRoot, opts);
+    }
+    for (const linkRoot of [claudeRoot, agentsRoot]) {
+        ensureDirSymlink(linkRoot, canonicalRoot);
+    }
+    opts.log?.(`skills merged into .pikiloop/skills and linked to .claude/.agents workdir=${workdir}`);
+}
+export function getProjectSkillPaths(workdir, skillName) {
+    const { canonicalRoot, claudeRoot, agentsRoot } = resolveProjectSkillRoots(workdir);
+    const sharedSkillFile = resolveSkillFile(canonicalRoot, skillName);
+    const agentsSkillFile = resolveSkillFile(agentsRoot, skillName);
+    const claudeSkillFile = resolveSkillFile(claudeRoot, skillName);
+    return {
+        sharedSkillFile: hasFile(sharedSkillFile) ? sharedSkillFile : null,
+        agentsSkillFile: hasFile(agentsSkillFile) ? agentsSkillFile : null,
+        claudeSkillFile: hasFile(claudeSkillFile) ? claudeSkillFile : null,
+    };
+}
+// Matches the canonical prompt produced by `resolveSkillPrompt` (bot/commands)
+// and `resolveSkillFromPrompt` (dashboard/session-control). Both build the same
+// shape: `[Project directory: <wd>]\n\nRead the skill definition at \`<path>\`
+// and execute the instructions defined there.[ Additional context: <args>]`.
+//
+// Whitespace between the segments is tolerant (`\s+`) so the regex still
+// matches after the claude driver collapses interior `\s+` to single spaces
+// when surfacing user text in `getClaudeSessionMessages`.
+const SKILL_PROMPT_RE = /^\[Project directory: [^\]\n]+?\]\s+Read the skill definition at `([^`\n]+)` and execute the instructions defined there\.(?:\s+Additional context:\s+([\s\S]+?))?\s*$/;
+/**
+ * Inverse of `resolveSkillPrompt`. When a stored user message matches the
+ * canonical skill-execution expansion, return the original `/skillname [args]`
+ * shorthand for display. Returns null when the text isn't a recognized skill
+ * prompt — callers should fall back to the raw text.
+ *
+ * The expanded form is what the agent CLI actually consumed and what gets
+ * persisted to its session log; this collapse exists purely so the dashboard
+ * (and other display surfaces) can render the slash command the user typed.
+ */
+export function collapseSkillPrompt(text) {
+    if (!text)
+        return null;
+    const m = SKILL_PROMPT_RE.exec(text);
+    if (!m)
+        return null;
+    // Skill files are always at `<root>/<skillName>/SKILL.md`. Split on both
+    // `/` and `\` so Windows-generated paths (path.join) resolve correctly.
+    const segments = m[1].split(/[/\\]/).filter(Boolean);
+    if (segments.length < 2 || segments[segments.length - 1] !== 'SKILL.md')
+        return null;
+    const name = segments[segments.length - 2];
+    if (!name)
+        return null;
+    const args = (m[2] || '').trim();
+    return args ? `/${name} ${args}` : `/${name}`;
+}
+const GLOBAL_SKILLS_ROOT = path.join(os.homedir(), STATE_DIR_NAME, 'skills');
+// Per-file cache of parsed SKILL.md metadata, keyed by file mtime. listSkills runs
+// on every skills-menu render (IM + dashboard); without this it re-read and
+// re-regex-parsed every SKILL.md each time. A changed skill re-parses just itself.
+const skillMetaCache = new Map();
+function discoverSkillsFromDir(dir, scope, seen) {
+    const skills = [];
+    for (const entry of readSortedDir(dir)) {
+        if (!entry || seen.has(entry))
+            continue;
+        const skillDir = path.join(dir, entry);
+        const skillFile = resolveSkillFile(dir, entry);
+        try {
+            if (!fs.statSync(skillDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        if (!hasFile(skillFile))
+            continue;
+        let meta = { label: null, description: null };
+        try {
+            const mtimeMs = fs.statSync(skillFile).mtimeMs;
+            const cached = skillMetaCache.get(skillFile);
+            if (cached && cached.mtimeMs === mtimeMs) {
+                meta = cached.meta;
+            }
+            else {
+                meta = parseSkillMeta(fs.readFileSync(skillFile, 'utf-8'));
+                skillMetaCache.set(skillFile, { mtimeMs, meta });
+            }
+        }
+        catch { }
+        skills.push({
+            name: entry,
+            label: meta.label,
+            description: meta.description,
+            source: 'skills',
+            scope,
+            mcpRequires: meta.mcpRequires,
+        });
+        seen.add(entry);
+    }
+    return skills;
+}
+/**
+ * List all skills — project-scoped (workdir) first, then global (~/.pikiloop/skills/).
+ * Project skills with the same name shadow global ones.
+ */
+export function listSkills(workdir) {
+    const seen = new Set();
+    const { canonicalRoot, legacyRoot } = resolveProjectSkillRoots(workdir);
+    // Project skills take precedence. Also scan the pre-rename `.pikiclaw/skills`
+    // dir so repos that committed project skills before the rename keep working.
+    const projectSkills = [
+        ...discoverSkillsFromDir(canonicalRoot, 'project', seen),
+        ...discoverSkillsFromDir(legacyRoot, 'project', seen),
+    ];
+    // Global skills fill in the rest
+    const globalSkills = discoverSkillsFromDir(GLOBAL_SKILLS_ROOT, 'global', seen);
+    return { skills: [...projectSkills, ...globalSkills], workdir };
+}
+/** Return the global skills root directory path. */
+export function getGlobalSkillsRoot() {
+    return GLOBAL_SKILLS_ROOT;
+}