@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/skills/resolver.js

@@ -0,0 +1,495 @@
+/**
+ * 2-Tier Skill Resolution System
+ *
+ * Cascade order (additive, later tiers override same-named skills):
+ *   Tier 1: Bundled skills (local-pack.ts — compiled into dist/)
+ *   Tier 2: Local directory skills (.unerr/skills/*.md + ~/.unerr/skills/*.md)
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { LOCAL_SKILLS } from "./local-pack.js";
+// ── IDE Skill Directory ────────────────────────────────────────────
+function getSkillDir(ide, cwd) {
+    switch (ide) {
+        case "claude-code":
+            // Claude Code uses directory-per-skill: .claude/skills/{name}/SKILL.md
+            return {
+                dir: join(cwd, ".claude", "skills"),
+                ext: ".md",
+                dirPerSkill: true,
+            };
+        case "cursor":
+            return {
+                dir: join(cwd, ".cursor", "rules"),
+                ext: ".mdc",
+                dirPerSkill: false,
+            };
+        case "vscode":
+            return {
+                dir: join(cwd, ".github", "copilot"),
+                ext: ".md",
+                dirPerSkill: false,
+            };
+        case "windsurf":
+            return {
+                dir: join(cwd, ".windsurf", "skills"),
+                ext: ".md",
+                dirPerSkill: true,
+            };
+        case "zed":
+            return {
+                dir: join(cwd, ".zed", "rules"),
+                ext: ".md",
+                dirPerSkill: false,
+            };
+        case "gemini-cli":
+            return {
+                dir: join(cwd, ".gemini", "skills"),
+                ext: ".md",
+                dirPerSkill: true,
+            };
+        case "github-copilot-cli":
+            return {
+                dir: join(cwd, ".github", "skills"),
+                ext: ".md",
+                dirPerSkill: true,
+            };
+        case "antigravity":
+            return {
+                dir: join(cwd, ".agents", "skills"),
+                ext: ".md",
+                dirPerSkill: true,
+            };
+        default:
+            return {
+                dir: join(cwd, ".unerr", "skills"),
+                ext: ".md",
+                dirPerSkill: false,
+            };
+    }
+}
+function writeSkillFile(skill, ide, skillDir, ext, dirPerSkill) {
+    mkdirSync(skillDir, { recursive: true });
+    // Strip existing "unerr-" prefix to avoid double-prefixing (e.g., from Tier 2 local skills)
+    const baseName = skill.name.replace(/^unerr-/, "");
+    const skillName = `unerr-${baseName}`;
+    let filePath;
+    let content;
+    if (dirPerSkill && ide === "windsurf") {
+        const skillSubDir = join(skillDir, skillName);
+        mkdirSync(skillSubDir, { recursive: true });
+        filePath = join(skillSubDir, "SKILL.md");
+        content = formatWindsurfSkillMd(skill);
+    }
+    else if (dirPerSkill && ide === "gemini-cli") {
+        const skillSubDir = join(skillDir, skillName);
+        mkdirSync(skillSubDir, { recursive: true });
+        filePath = join(skillSubDir, "SKILL.md");
+        content = formatGeminiSkill(skill);
+    }
+    else if (dirPerSkill && ide === "github-copilot-cli") {
+        const skillSubDir = join(skillDir, skillName);
+        mkdirSync(skillSubDir, { recursive: true });
+        filePath = join(skillSubDir, "SKILL.md");
+        content = formatCopilotSkill(skill);
+    }
+    else if (dirPerSkill && ide === "antigravity") {
+        const skillSubDir = join(skillDir, skillName);
+        mkdirSync(skillSubDir, { recursive: true });
+        filePath = join(skillSubDir, "SKILL.md");
+        content = formatAntigravitySkill(skill);
+    }
+    else if (dirPerSkill) {
+        // Claude Code: .claude/skills/{skill-name}/SKILL.md
+        const skillSubDir = join(skillDir, skillName);
+        mkdirSync(skillSubDir, { recursive: true });
+        filePath = join(skillSubDir, "SKILL.md");
+        content = formatClaudeCodeSkill(skill);
+    }
+    else if (ide === "cursor" && ext === ".mdc") {
+        filePath = join(skillDir, `${skillName}${ext}`);
+        content = formatCursorSkill(skill);
+    }
+    else {
+        filePath = join(skillDir, `${skillName}${ext}`);
+        content = formatMarkdownSkill(skill);
+    }
+    writeFileSync(filePath, content);
+    return filePath;
+}
+/** Claude Code SKILL.md format — directory-per-skill with proper frontmatter */
+function formatClaudeCodeSkill(skill) {
+    const trigger = skill.trigger;
+    const triggerType = trigger?.type ?? "always";
+    // Map unerr trigger types to Claude Code frontmatter fields
+    let disableModelInvocation = false;
+    let userInvocable = true;
+    let paths;
+    switch (triggerType) {
+        case "always":
+            // Claude loads automatically, user can also invoke
+            break;
+        case "auto":
+            // Claude loads when working with matching files
+            paths = trigger?.globs;
+            break;
+        case "agent-requested":
+            // Only Claude invokes, not shown in / menu
+            userInvocable = false;
+            break;
+        case "manual":
+            // Only user can invoke via /skill-name
+            disableModelInvocation = true;
+            break;
+    }
+    // Build frontmatter
+    let frontmatter = `description: "${skill.description}"`;
+    if (disableModelInvocation) {
+        frontmatter += "\ndisable-model-invocation: true";
+    }
+    if (!userInvocable) {
+        frontmatter += "\nuser-invocable: false";
+    }
+    if (paths && paths.length > 0) {
+        frontmatter += `\npaths: ${paths.join(", ")}`;
+    }
+    return `---
+${frontmatter}
+---
+
+${skill.content}
+`;
+}
+/** Cursor .mdc format with trigger-aware frontmatter */
+function formatCursorSkill(skill) {
+    const trigger = skill.trigger;
+    const triggerType = trigger?.type ?? "always";
+    // Map unerr trigger types to Cursor .mdc fields
+    let alwaysApply;
+    let globs;
+    switch (triggerType) {
+        case "always":
+            alwaysApply = true;
+            globs = [];
+            break;
+        case "auto":
+            // Auto-triggered skills should always apply in Cursor — Cursor's glob matching
+            // is unreliable, and these skills contain critical behavioral instructions
+            alwaysApply = true;
+            globs = [];
+            break;
+        case "agent-requested":
+            // Cursor: not alwaysApply, no globs → description-based activation
+            alwaysApply = false;
+            globs = [];
+            break;
+        case "manual":
+            alwaysApply = false;
+            globs = [];
+            break;
+        default:
+            alwaysApply = true;
+            globs = [];
+    }
+    const globLine = globs.length > 0 ? `\nglobs: ${JSON.stringify(globs)}` : "";
+    return `---
+unerr_skill_version: "${skill.version ?? "1.0.0"}"
+description: "${skill.description}"${globLine}
+alwaysApply: ${alwaysApply}
+---
+
+${skill.content}
+`;
+}
+/** Standard markdown format for Claude Code, VS Code, Zed */
+function formatMarkdownSkill(skill) {
+    const trigger = skill.trigger;
+    const triggerType = trigger?.type ?? "always";
+    const globLine = trigger?.globs && trigger.globs.length > 0
+        ? `\nglobs: ${JSON.stringify(trigger.globs)}`
+        : "";
+    return `---
+description: "${skill.description}"
+trigger: ${triggerType}${globLine}
+version: "${skill.version ?? "1.0.0"}"
+---
+
+# ${skill.name}
+
+${skill.content}
+`;
+}
+/**
+ * Format a skill for Windsurf.
+ * Windsurf skills use folder-per-skill: .windsurf/skills/{name}/SKILL.md
+ * with YAML frontmatter (name, description).
+ */
+function formatWindsurfSkillMd(skill) {
+    return `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+${skill.content}
+`;
+}
+/**
+ * Format a skill for Gemini CLI.
+ * Gemini CLI skills use folder-per-skill: .gemini/skills/{name}/SKILL.md
+ * with YAML frontmatter (name, description).
+ */
+function formatGeminiSkill(skill) {
+    return `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+${skill.content}
+`;
+}
+/**
+ * Format a skill for GitHub Copilot CLI.
+ * Copilot skills use folder-per-skill: .github/skills/{name}/SKILL.md
+ * with YAML frontmatter (name, description, allowed-tools).
+ */
+function formatCopilotSkill(skill) {
+    return `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+${skill.content}
+`;
+}
+/**
+ * Format a skill for Google Antigravity.
+ * Antigravity skills use folder-per-skill: .agents/skills/{name}/SKILL.md
+ * with YAML frontmatter (name, description).
+ */
+function formatAntigravitySkill(skill) {
+    const trigger = skill.trigger;
+    const triggerType = trigger?.type ?? "always";
+    let globs = [];
+    if (trigger?.globs) {
+        globs = trigger.globs;
+    }
+    let frontmatter = `---\nname: ${skill.name}\ndescription: ${skill.description}`;
+    if (globs.length > 0) {
+        frontmatter += `\nglobs:\n${globs.map((g) => `  - ${g}`).join("\n")}`;
+    }
+    if (triggerType === "manual") {
+        frontmatter += "\nuser_invocable: true";
+    }
+    frontmatter += "\n---";
+    return `${frontmatter}\n\n${skill.content}\n`;
+}
+// ── Tier 1: Bundled Skills ─────────────────────────────────────────
+function loadBundledSkills() {
+    return LOCAL_SKILLS.map((s) => ({
+        name: s.id,
+        description: s.description,
+        content: s.instructions,
+        version: s.version,
+        source: "bundled",
+        trigger: s.trigger,
+    }));
+}
+// ── Tier 2: Local Directory Skills ─────────────────────────────────
+/**
+ * Parse optional YAML-like frontmatter from a .md skill file.
+ * Supports: name, description, version in `---` delimited block.
+ */
+function parseFrontmatter(raw) {
+    const meta = {};
+    if (!raw.startsWith("---")) {
+        return { meta, content: raw };
+    }
+    const endIdx = raw.indexOf("---", 3);
+    if (endIdx === -1) {
+        return { meta, content: raw };
+    }
+    const frontBlock = raw.slice(3, endIdx).trim();
+    for (const line of frontBlock.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const value = line
+            .slice(colonIdx + 1)
+            .trim()
+            .replace(/^["']|["']$/g, "");
+        if (key && value)
+            meta[key] = value;
+    }
+    const content = raw.slice(endIdx + 3).trim();
+    return { meta, content };
+}
+/**
+ * Scan a directory for .md skill files.
+ * Returns skills with optional YAML frontmatter parsed.
+ */
+export function scanSkillDirectory(dir) {
+    if (!existsSync(dir))
+        return [];
+    const skills = [];
+    try {
+        const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+        for (const file of files) {
+            try {
+                const raw = readFileSync(join(dir, file), "utf-8");
+                const { meta, content } = parseFrontmatter(raw);
+                const name = meta.name ?? file.replace(/\.md$/, "");
+                skills.push({
+                    name,
+                    description: meta.description ?? `Local skill: ${name}`,
+                    content,
+                    version: meta.version,
+                    source: "local",
+                });
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+    }
+    catch {
+        // Directory unreadable
+    }
+    return skills;
+}
+/**
+ * Load Tier 2 skills from project (.unerr/skills/) and user (~/.unerr/skills/).
+ * Project-level overrides user-level on same name.
+ */
+function loadLocalDirectorySkills(cwd) {
+    const userDir = join(homedir(), ".unerr", "skills");
+    const projectDir = join(cwd, ".unerr", "skills");
+    const userSkills = scanSkillDirectory(userDir);
+    const projectSkills = scanSkillDirectory(projectDir);
+    // Project overrides user on same name
+    const byName = new Map();
+    for (const s of userSkills)
+        byName.set(s.name, s);
+    for (const s of projectSkills)
+        byName.set(s.name, s);
+    return Array.from(byName.values());
+}
+// ── Cascade Resolution ─────────────────────────────────────────────
+/**
+ * Resolve skills from Tier 1 (bundled) and Tier 2 (local directories),
+ * then install them into the IDE skill directory.
+ *
+ * Tiers are ADDITIVE: Tier 1 → Tier 2 supplements/overrides.
+ */
+export async function resolveAndInstallSkills(opts) {
+    const byName = new Map();
+    // Tier 1: Bundled
+    for (const s of loadBundledSkills())
+        byName.set(s.name, s);
+    // Tier 2: Local directories
+    for (const s of loadLocalDirectorySkills(opts.cwd))
+        byName.set(s.name, s);
+    // Install resolved skills into IDE directory
+    const skills = Array.from(byName.values());
+    const { dir, ext, dirPerSkill } = getSkillDir(opts.ide, opts.cwd);
+    const installed = [];
+    for (const skill of skills) {
+        try {
+            writeSkillFile(skill, opts.ide, dir, ext, dirPerSkill);
+            installed.push(skill.name);
+        }
+        catch {
+            // Non-blocking: skip failed installs
+        }
+    }
+    // Build source attribution string
+    const sources = new Set(skills.map((s) => s.source));
+    const source = Array.from(sources).join("+");
+    return { installed, source, skills };
+}
+/**
+ * Check if skills are present in the IDE directory.
+ * If missing, run the full cascade silently.
+ *
+ * Called on every proxy boot for self-healing.
+ * Returns the number of skills installed (0 = already present).
+ */
+export async function ensureSkillsPresent(opts) {
+    const { dir, ext, dirPerSkill } = getSkillDir(opts.ide, opts.cwd);
+    // Check if any unerr skills exist
+    if (existsSync(dir)) {
+        try {
+            const entries = readdirSync(dir);
+            let hasSkills;
+            if (dirPerSkill) {
+                // Claude Code: check for unerr-*/SKILL.md directories
+                hasSkills = entries.some((f) => f.startsWith("unerr-") && existsSync(join(dir, f, "SKILL.md")));
+            }
+            else {
+                hasSkills = entries.some((f) => f.startsWith("unerr-") && f.endsWith(ext));
+            }
+            if (hasSkills)
+                return 0; // Skills present, nothing to do
+        }
+        catch {
+            // Directory unreadable, reinstall
+        }
+    }
+    // Skills missing — run cascade
+    const result = await resolveAndInstallSkills(opts);
+    return result.installed.length;
+}
+/**
+ * List installed skills from the IDE directory with source detection.
+ */
+export function listInstalledSkills(ide, cwd) {
+    const { dir, ext, dirPerSkill } = getSkillDir(ide, cwd);
+    if (!existsSync(dir))
+        return [];
+    try {
+        if (dirPerSkill) {
+            // Claude Code: .claude/skills/unerr-{name}/SKILL.md
+            return readdirSync(dir)
+                .filter((f) => f.startsWith("unerr-") && existsSync(join(dir, f, "SKILL.md")))
+                .map((f) => ({
+                name: f.replace("unerr-", ""),
+                path: join(dir, f, "SKILL.md"),
+            }));
+        }
+        return readdirSync(dir)
+            .filter((f) => f.startsWith("unerr-") && f.endsWith(ext))
+            .map((f) => ({
+            name: f.replace("unerr-", "").replace(ext, ""),
+            path: join(dir, f),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Remove all unerr-installed skills for an IDE.
+ * Returns the number of skills removed.
+ */
+export function removeInstalledSkills(ide, cwd) {
+    const skills = listInstalledSkills(ide, cwd);
+    const { dirPerSkill } = getSkillDir(ide, cwd);
+    let removed = 0;
+    for (const skill of skills) {
+        try {
+            if (dirPerSkill) {
+                // Claude Code: remove the entire unerr-{name}/ directory
+                rmSync(dirname(skill.path), { recursive: true, force: true });
+            }
+            else {
+                unlinkSync(skill.path);
+            }
+            removed++;
+        }
+        catch {
+            // Non-blocking
+        }
+    }
+    return removed;
+}

package/dist/state-detector.js

@@ -0,0 +1,83 @@
+/**
+ * Smart Default State Detector — pure function that inspects the local
+ * environment and determines what action the CLI should take.
+ *
+ * State priority (checked top-to-bottom):
+ *   1. Not inside a git repo     → not_git_repo
+ *   2. No .unerr/config.json     → needs_setup
+ *   3. PID file present + alive  → already_running
+ *   4. PID file present + dead   → stale_pid (cleaned, becomes ready)
+ *   5. Everything good            → ready
+ */
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { isGitRepo as isGitRepoAsync } from "./utils/git.js";
+/**
+ * Inspect environment → return state.
+ * All I/O is read-only (except stale PID cleanup).
+ */
+export async function detectState(deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    // 1. Git repo
+    const checkGitRepo = deps.isGitRepo ?? (() => isGitRepoAsync(cwd));
+    if (!(await checkGitRepo())) {
+        return { state: "not_git_repo" };
+    }
+    // 2. Config
+    const configPath = join(cwd, ".unerr", "config.json");
+    if (!existsSync(configPath)) {
+        return { state: "needs_setup" };
+    }
+    let repoId;
+    try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        repoId = config.repoId;
+    }
+    catch {
+        return { state: "needs_setup" };
+    }
+    // 3/4. PID check — supports both JSON { pid, startedAt, healthPort } and legacy plain number
+    const pidPath = join(cwd, ".unerr", "state", "proxy.pid");
+    if (existsSync(pidPath)) {
+        try {
+            const raw = readFileSync(pidPath, "utf-8").trim();
+            let pid;
+            if (raw.startsWith("{")) {
+                const data = JSON.parse(raw);
+                pid = data.pid;
+            }
+            else {
+                pid = Number.parseInt(raw, 10);
+            }
+            if (pid && !Number.isNaN(pid) && isProcessAlive(pid)) {
+                return { state: "already_running", pid, repoId };
+            }
+            // Stale PID — clean up
+            unlinkSync(pidPath);
+            return { state: "stale_pid", pid, repoId };
+        }
+        catch {
+            // PID file unreadable — treat as stale
+            try {
+                unlinkSync(pidPath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    // 5. All good
+    return { state: "ready", repoId };
+}
+/**
+ * Check if a process is alive via kill(pid, 0).
+ */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}