@sporesec/arcana 2.4.0 → 3.0.0

package/dist/interactive/search.js

@@ -0,0 +1,66 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { isSkillInstalled } from "../utils/fs.js";
+import { getProvider } from "../registry.js";
+import { ui } from "../utils/ui.js";
+import { appendHistory } from "../utils/history.js";
+import { handleCancel, truncate } from "./helpers.js";
+import { skillDetailFlow } from "./skill-detail.js";
+export async function searchFlow(allSkills, providerName) {
+    while (true) {
+        const query = await p.text({
+            message: "Search for:",
+            placeholder: "e.g. testing, review, golang",
+            validate: (v) => (!v || v.trim().length === 0 ? "Enter a search term" : undefined),
+        });
+        handleCancel(query);
+        const provider = getProvider(providerName);
+        const s = p.spinner();
+        s.start(`Searching "${query}"...`);
+        let results;
+        try {
+            results = await provider.search(query);
+        }
+        catch (err) {
+            s.stop("Search failed");
+            if (err instanceof Error)
+                p.log.error(ui.dim(err.message));
+            return;
+        }
+        s.stop(`${results.length} result${results.length !== 1 ? "s" : ""}`);
+        appendHistory("search", query);
+        if (results.length === 0) {
+            p.log.info("No skills matched. Try a different query.");
+            const again = await p.confirm({ message: "Search again?" });
+            handleCancel(again);
+            if (!again)
+                return;
+            continue;
+        }
+        const nav = await searchResultsPicker(results, allSkills, providerName);
+        if (nav === "done")
+            return;
+        // "search" continues the loop
+    }
+}
+async function searchResultsPicker(results, allSkills, providerName) {
+    while (true) {
+        const options = results.map((skill) => ({
+            value: skill.name,
+            label: `${skill.name}${isSkillInstalled(skill.name) ? chalk.green(" \u2713") : ""}`,
+            hint: truncate(skill.description, 50),
+        }));
+        const picked = await p.select({
+            message: "Pick a skill for details",
+            options: [...options, { value: "__search", label: "Search again" }, { value: "__back", label: "Back" }],
+        });
+        handleCancel(picked);
+        if (picked === "__search")
+            return "search";
+        if (picked === "__back")
+            return "done";
+        const result = await skillDetailFlow(picked, allSkills, providerName);
+        if (result === "menu")
+            return "done";
+    }
+}

package/dist/interactive/setup.d.ts

@@ -0,0 +1,2 @@
+import type { SkillInfo } from "../types.js";
+export declare function quickSetup(allSkills: SkillInfo[], providerName: string): Promise<void>;

package/dist/interactive/setup.js

@@ -0,0 +1,48 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { isSkillInstalled } from "../utils/fs.js";
+import { handleCancel } from "./helpers.js";
+import { doBatchInstall } from "./browse.js";
+export async function quickSetup(allSkills, providerName) {
+    const { detectProject, SKILL_SUGGESTIONS, SKILL_SUGGESTIONS_DEFAULT } = await import("../commands/init.js");
+    const proj = detectProject(process.cwd());
+    p.log.step(`Detected: ${chalk.cyan(proj.name)} (${proj.type})`);
+    const suggestions = SKILL_SUGGESTIONS[proj.type] ?? SKILL_SUGGESTIONS_DEFAULT;
+    const availableNames = new Set(allSkills.map((s) => s.name));
+    const validSuggestions = suggestions.filter((s) => availableNames.has(s));
+    if (validSuggestions.length === 0) {
+        p.log.info("No specific recommendations for this project type.");
+        return;
+    }
+    const notInstalled = validSuggestions.filter((s) => !isSkillInstalled(s));
+    if (notInstalled.length === 0) {
+        p.log.success("All recommended skills are already installed.");
+        return;
+    }
+    const options = validSuggestions.map((name) => {
+        const installed = isSkillInstalled(name);
+        return {
+            value: name,
+            label: `${name}${installed ? chalk.green(" \u2713 installed") : ""}`,
+            hint: installed ? "already installed" : "not installed",
+        };
+    });
+    const selected = await p.multiselect({
+        message: `Recommended skills for ${proj.type}`,
+        options,
+        required: false,
+    });
+    handleCancel(selected);
+    const toInstall = selected.filter((s) => !isSkillInstalled(s));
+    if (toInstall.length > 0) {
+        await doBatchInstall(toInstall, providerName);
+    }
+    else if (selected.length > 0) {
+        p.log.info("All selected skills are already installed.");
+    }
+    if (!existsSync(join(process.cwd(), "CLAUDE.md"))) {
+        p.log.info(`Tip: Run ${chalk.cyan("arcana init")} to create project config files.`);
+    }
+}

package/dist/interactive/skill-detail.d.ts

@@ -0,0 +1,5 @@
+import type { SkillInfo } from "../types.js";
+declare function doInstall(skillName: string, providerName: string): Promise<boolean>;
+declare function doUninstall(skillName: string): boolean;
+export declare function skillDetailFlow(skillName: string, allSkills: SkillInfo[], providerName: string): Promise<"back" | "menu">;
+export { doInstall, doUninstall };

package/dist/interactive/skill-detail.js

@@ -0,0 +1,126 @@
+import { existsSync, rmSync } from "node:fs";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { isSkillInstalled, readSkillMeta, getSkillDir } from "../utils/fs.js";
+import { getProvider } from "../registry.js";
+import { appendHistory } from "../utils/history.js";
+import { installOneCore } from "../utils/install-core.js";
+import { removeSymlinksFor } from "../commands/uninstall.js";
+import { ui } from "../utils/ui.js";
+import { handleCancel } from "./helpers.js";
+import { getCategoryFor, getRelatedSkills } from "./categories.js";
+async function doInstall(skillName, providerName) {
+    const provider = getProvider(providerName);
+    const s = p.spinner();
+    s.start(`Installing ${chalk.bold(skillName)}...`);
+    try {
+        const result = await installOneCore(skillName, provider, {});
+        if (!result.success) {
+            s.stop(`Failed to install ${skillName}`);
+            if (result.error)
+                p.log.error(ui.dim(result.error));
+            return false;
+        }
+        s.stop(`Installed ${chalk.bold(skillName)} (${result.files?.length ?? 0} files)`);
+        appendHistory("install", skillName);
+        return true;
+    }
+    catch (err) {
+        s.stop(`Failed to install ${skillName}`);
+        if (err instanceof Error)
+            p.log.error(ui.dim(err.message));
+        return false;
+    }
+}
+function doUninstall(skillName) {
+    const skillDir = getSkillDir(skillName);
+    if (!existsSync(skillDir))
+        return false;
+    try {
+        rmSync(skillDir, { recursive: true, force: true });
+        removeSymlinksFor(skillName);
+        appendHistory("uninstall", skillName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function skillDetailFlow(skillName, allSkills, providerName) {
+    const info = allSkills.find((s) => s.name === skillName);
+    const installed = isSkillInstalled(skillName);
+    const meta = installed ? readSkillMeta(skillName) : null;
+    // Build info block
+    const lines = [];
+    lines.push(`${chalk.bold(skillName)} ${info ? `v${info.version}` : ""}`);
+    if (info?.description)
+        lines.push(info.description);
+    lines.push("");
+    if (info?.verified)
+        lines.push(`Trust: ${chalk.green("Verified")} (official)`);
+    else
+        lines.push(`Trust: Community`);
+    if (info?.author)
+        lines.push(`Author: ${info.author}`);
+    if (info?.tags && info.tags.length > 0)
+        lines.push(`Tags: ${info.tags.join(", ")}`);
+    const category = getCategoryFor(skillName);
+    if (category)
+        lines.push(`Category: ${category}`);
+    if (info?.source)
+        lines.push(`Source: ${info.source}`);
+    if (info?.companions && info.companions.length > 0) {
+        lines.push(`Companions: ${info.companions.join(", ")}`);
+    }
+    if (info?.conflicts && info.conflicts.length > 0) {
+        lines.push(`${chalk.red("Conflicts:")} ${info.conflicts.join(", ")}`);
+    }
+    if (installed && meta) {
+        const date = meta.installedAt ? new Date(meta.installedAt).toLocaleDateString() : "";
+        lines.push(`Status: ${chalk.green("installed")} (v${meta.version}${date ? `, ${date}` : ""})`);
+    }
+    else {
+        lines.push(`Status: ${chalk.dim("not installed")}`);
+    }
+    const related = getRelatedSkills(skillName);
+    if (related.length > 0) {
+        lines.push(`Related: ${related.join(", ")}`);
+    }
+    p.note(lines.join("\n"), skillName);
+    // Action menu
+    const actions = [];
+    if (installed) {
+        actions.push({ value: "reinstall", label: "Reinstall (overwrite)" });
+        actions.push({ value: "uninstall", label: "Uninstall (remove files)" });
+    }
+    else {
+        actions.push({ value: "install", label: "Install this skill" });
+    }
+    actions.push({ value: "back", label: "Back" });
+    const action = await p.select({ message: "Action", options: actions });
+    handleCancel(action);
+    switch (action) {
+        case "install":
+        case "reinstall": {
+            await doInstall(skillName, providerName);
+            return "back";
+        }
+        case "uninstall": {
+            const ok = await p.confirm({ message: `Uninstall ${chalk.bold(skillName)}?` });
+            handleCancel(ok);
+            if (ok) {
+                const success = doUninstall(skillName);
+                if (success) {
+                    p.log.success(`Removed ${chalk.bold(skillName)}`);
+                }
+                else {
+                    p.log.error(`Failed to remove ${skillName}`);
+                }
+            }
+            return "back";
+        }
+        default:
+            return "back";
+    }
+}
+export { doInstall, doUninstall };

package/dist/interactive.d.ts

@@ -1,2 +1 @@
 export declare function showInteractiveMenu(version: string): Promise<void>;
-//# sourceMappingURL=interactive.d.ts.map

package/dist/interactive.js

@@ -18,39 +18,74 @@ const AMBER = chalk.hex("#d4943a");
 // ---------------------------------------------------------------------------
 const SKILL_CATEGORIES = {
     "Code Quality & Review": [
-        "code-reviewer", "codebase-dissection", "testing-strategy",
-        "refactoring-patterns", "git-workflow", "pre-production-review",
-        "frontend-code-review", "dependency-audit", "performance-optimization",
+        "code-reviewer",
+        "codebase-dissection",
+        "testing-strategy",
+        "refactoring-patterns",
+        "git-workflow",
+        "pre-production-review",
+        "frontend-code-review",
+        "dependency-audit",
+        "performance-optimization",
     ],
     "Security & Infrastructure": [
-        "security-review", "local-security", "container-security",
-        "docker-kubernetes", "ci-cd-pipelines", "ci-cd-automation",
-        "monitoring-observability", "incident-response",
+        "security-review",
+        "local-security",
+        "container-security",
+        "docker-kubernetes",
+        "ci-cd-pipelines",
+        "ci-cd-automation",
+        "monitoring-observability",
+        "incident-response",
     ],
     "Languages & Frameworks": [
-        "golang-pro", "go-linter-configuration", "typescript", "typescript-advanced",
-        "python-best-practices", "rust-best-practices", "frontend-design",
-        "fullstack-developer", "remotion-best-practices", "npm-package",
+        "golang-pro",
+        "go-linter-configuration",
+        "typescript",
+        "typescript-advanced",
+        "python-best-practices",
+        "rust-best-practices",
+        "frontend-design",
+        "fullstack-developer",
+        "remotion-best-practices",
+        "npm-package",
     ],
     "API, Data & Docs": [
-        "api-design", "api-testing", "programming-architecture",
-        "database-design", "env-config", "cost-optimization",
-        "docx", "xlsx", "doc-generation", "update-docs",
+        "api-design",
+        "api-testing",
+        "programming-architecture",
+        "database-design",
+        "env-config",
+        "cost-optimization",
+        "docx",
+        "xlsx",
+        "doc-generation",
+        "update-docs",
     ],
     "Game Design & Production": [
-        "game-design-theory", "game-engines", "game-programming-languages",
-        "gameplay-mechanics", "level-design", "game-tools-workflows",
-        "game-servers", "networking-servers", "synchronization-algorithms",
-        "monetization-systems", "publishing-platforms", "daw-music",
+        "game-design-theory",
+        "game-engines",
+        "game-programming-languages",
+        "gameplay-mechanics",
+        "level-design",
+        "game-tools-workflows",
+        "game-servers",
+        "networking-servers",
+        "synchronization-algorithms",
+        "monetization-systems",
+        "publishing-platforms",
+        "daw-music",
     ],
     "Graphics, Audio & Performance": [
-        "graphics-rendering", "shader-techniques", "particle-systems",
-        "audio-systems", "asset-optimization", "optimization-performance",
+        "graphics-rendering",
+        "shader-techniques",
+        "particle-systems",
+        "audio-systems",
+        "asset-optimization",
+        "optimization-performance",
         "memory-management",
     ],
-    "Skill Development": [
-        "skill-creation-guide", "skill-creator", "find-skills", "project-migration",
-    ],
+    "Skill Development": ["skill-creation-guide", "skill-creator", "find-skills", "project-migration"],
 };
 // ---------------------------------------------------------------------------
 // Helpers
@@ -68,7 +103,7 @@ function countInstalled() {
     const dir = getInstallDir();
     if (!existsSync(dir))
         return 0;
-    return readdirSync(dir).filter(d => {
+    return readdirSync(dir).filter((d) => {
         try {
             return statSync(join(dir, d)).isDirectory();
         }
@@ -91,16 +126,14 @@ function getRelatedSkills(skillName, limit = 3) {
     const cat = getCategoryFor(skillName);
     if (!cat)
         return [];
-    return (SKILL_CATEGORIES[cat] ?? [])
-        .filter(s => s !== skillName && !isSkillInstalled(s))
-        .slice(0, limit);
+    return (SKILL_CATEGORIES[cat] ?? []).filter((s) => s !== skillName && !isSkillInstalled(s)).slice(0, limit);
 }
 function getInstalledNames() {
     const dir = getInstallDir();
     if (!existsSync(dir))
         return [];
     return readdirSync(dir)
-        .filter(d => {
+        .filter((d) => {
         try {
             return statSync(join(dir, d)).isDirectory();
         }
@@ -110,7 +143,7 @@ function getInstalledNames() {
     })
         .sort();
 }
-function buildMenuOptions(installedCount, availableCount) {
+function buildMenuOptions(installedCount, _availableCount) {
     const isNew = installedCount === 0;
     const options = [];
     if (isNew) {
@@ -211,7 +244,7 @@ function doUninstall(skillName) {
 // Skill Detail View (central action point)
 // ---------------------------------------------------------------------------
 async function skillDetailFlow(skillName, allSkills, providerName) {
-    const info = allSkills.find(s => s.name === skillName);
+    const info = allSkills.find((s) => s.name === skillName);
     const installed = isSkillInstalled(skillName);
     const meta = installed ? readSkillMeta(skillName) : null;
     // Build info block
@@ -277,11 +310,11 @@ async function skillDetailFlow(skillName, allSkills, providerName) {
 // Browse by Category
 // ---------------------------------------------------------------------------
 async function browseByCategory(allSkills, providerName) {
-    const availableNames = new Set(allSkills.map(s => s.name));
+    const availableNames = new Set(allSkills.map((s) => s.name));
     while (true) {
         const categoryOptions = Object.entries(SKILL_CATEGORIES).map(([name, skills]) => {
-            const valid = skills.filter(s => availableNames.has(s));
-            const installedCount = valid.filter(s => isSkillInstalled(s)).length;
+            const valid = skills.filter((s) => availableNames.has(s));
+            const installedCount = valid.filter((s) => isSkillInstalled(s)).length;
             return {
                 value: name,
                 label: name,
@@ -290,10 +323,7 @@ async function browseByCategory(allSkills, providerName) {
         });
         const category = await p.select({
             message: "Browse by category",
-            options: [
-                ...categoryOptions,
-                { value: "__back", label: "Back" },
-            ],
+            options: [...categoryOptions, { value: "__back", label: "Back" }],
         });
         handleCancel(category);
         if (category === "__back")
@@ -302,15 +332,15 @@ async function browseByCategory(allSkills, providerName) {
     }
 }
 async function categorySkillList(categoryName, skillNames, allSkills, providerName) {
-    const availableNames = new Set(allSkills.map(s => s.name));
-    const validSkills = skillNames.filter(s => availableNames.has(s));
+    const availableNames = new Set(allSkills.map((s) => s.name));
+    const validSkills = skillNames.filter((s) => availableNames.has(s));
     if (validSkills.length === 0) {
         p.log.warn("No skills found in this category.");
         return;
     }
     while (true) {
-        const options = validSkills.map(name => {
-            const info = allSkills.find(s => s.name === name);
+        const options = validSkills.map((name) => {
+            const info = allSkills.find((s) => s.name === name);
             const installed = isSkillInstalled(name);
             return {
                 value: name,
@@ -318,7 +348,7 @@ async function categorySkillList(categoryName, skillNames, allSkills, providerNa
                 hint: truncate(info?.description ?? "", 50),
             };
         });
-        const notInstalled = validSkills.filter(s => !isSkillInstalled(s));
+        const notInstalled = validSkills.filter((s) => !isSkillInstalled(s));
         const extraOptions = [];
         if (notInstalled.length > 0) {
             extraOptions.push({
@@ -386,18 +416,14 @@ async function searchFlow(allSkills, providerName) {
 }
 async function searchResultsPicker(results, allSkills, providerName) {
     while (true) {
-        const options = results.map(skill => ({
+        const options = results.map((skill) => ({
             value: skill.name,
             label: `${skill.name}${isSkillInstalled(skill.name) ? chalk.green(" \u2713") : ""}`,
             hint: truncate(skill.description, 50),
         }));
         const picked = await p.select({
             message: "Pick a skill for details",
-            options: [
-                ...options,
-                { value: "__search", label: "Search again" },
-                { value: "__back", label: "Back" },
-            ],
+            options: [...options, { value: "__search", label: "Search again" }, { value: "__back", label: "Back" }],
         });
         handleCancel(picked);
         if (picked === "__search")
@@ -417,7 +443,7 @@ async function quickSetup(allSkills, providerName) {
     const proj = detectProject(process.cwd());
     p.log.step(`Detected: ${chalk.cyan(proj.name)} (${proj.type})`);
     const suggestions = SKILL_SUGGESTIONS[proj.type] ?? SKILL_SUGGESTIONS_DEFAULT;
-    const availableNames = new Set(allSkills.map(s => s.name));
+    const availableNames = new Set(allSkills.map((s) => s.name));
     const validSuggestions = suggestions.filter((s) => availableNames.has(s));
     if (validSuggestions.length === 0) {
         p.log.info("No specific recommendations for this project type.");
@@ -467,17 +493,17 @@ async function manageInstalled(allSkills, providerName) {
         const groups = [];
         const categorized = new Set();
         for (const [cat, catSkills] of Object.entries(SKILL_CATEGORIES)) {
-            const installed = catSkills.filter(s => names.includes(s));
+            const installed = catSkills.filter((s) => names.includes(s));
             if (installed.length > 0) {
                 groups.push({ cat, skills: installed });
-                installed.forEach(s => categorized.add(s));
+                installed.forEach((s) => categorized.add(s));
             }
         }
-        const uncategorized = names.filter(s => !categorized.has(s));
+        const uncategorized = names.filter((s) => !categorized.has(s));
         if (uncategorized.length > 0) {
             groups.push({ cat: "Other", skills: uncategorized });
         }
-        const options = groups.map(g => ({
+        const options = groups.map((g) => ({
             value: g.cat,
             label: g.cat,
             hint: `${g.skills.length} installed`,
@@ -502,7 +528,7 @@ async function manageInstalled(allSkills, providerName) {
             await bulkUninstall(names);
             continue;
         }
-        const group = groups.find(g => g.cat === picked);
+        const group = groups.find((g) => g.cat === picked);
         if (group) {
             await installedCategoryList(group.cat, group.skills, allSkills, providerName);
         }
@@ -510,12 +536,12 @@ async function manageInstalled(allSkills, providerName) {
 }
 async function installedCategoryList(categoryName, installedNames, allSkills, providerName) {
     while (true) {
-        const stillInstalled = installedNames.filter(s => isSkillInstalled(s));
+        const stillInstalled = installedNames.filter((s) => isSkillInstalled(s));
         if (stillInstalled.length === 0) {
             p.log.info("No skills remaining in this category.");
             return;
         }
-        const options = stillInstalled.map(name => {
+        const options = stillInstalled.map((name) => {
             const meta = readSkillMeta(name);
             const ver = meta ? `v${meta.version}` : "";
             const date = meta?.installedAt ? new Date(meta.installedAt).toLocaleDateString() : "";
@@ -540,7 +566,7 @@ async function installedCategoryList(categoryName, installedNames, allSkills, pr
 async function bulkUninstall(installedNames) {
     const selected = await p.multiselect({
         message: "Select skills to uninstall",
-        options: installedNames.map(name => ({ value: name, label: name })),
+        options: installedNames.map((name) => ({ value: name, label: name })),
         required: false,
         maxItems: 15,
     });
@@ -583,7 +609,7 @@ async function updateAll(providerName) {
             p.log.error(ui.dim(err.message));
         return;
     }
-    const remoteMap = new Map(remoteSkills.map(rs => [rs.name, rs]));
+    const remoteMap = new Map(remoteSkills.map((rs) => [rs.name, rs]));
     const updates = [];
     for (const name of installed) {
         const remote = remoteMap.get(name);
@@ -642,15 +668,13 @@ async function checkHealth() {
     const checks = runDoctorChecks();
     p.log.step(chalk.bold("Environment Health Check"));
     for (const check of checks) {
-        const icon = check.status === "pass" ? chalk.green("OK")
-            : check.status === "warn" ? chalk.yellow("!!")
-                : chalk.red("XX");
+        const icon = check.status === "pass" ? chalk.green("OK") : check.status === "warn" ? chalk.yellow("!!") : chalk.red("XX");
         p.log.info(`${icon}  ${chalk.bold(check.name)}: ${check.message}`);
         if (check.fix)
             p.log.info(chalk.dim(`    Fix: ${check.fix}`));
     }
-    const fails = checks.filter(c => c.status === "fail").length;
-    const warns = checks.filter(c => c.status === "warn").length;
+    const fails = checks.filter((c) => c.status === "fail").length;
+    const warns = checks.filter((c) => c.status === "warn").length;
     if (fails > 0) {
         p.log.error(`${fails} issue${fails > 1 ? "s" : ""} found`);
     }
@@ -662,10 +686,10 @@ async function checkHealth() {
         return;
     }
     // Offer fixes once - no loop. User can re-enter health check to verify.
-    const fixChecks = checks.filter(c => c.fix && c.status !== "pass");
+    const fixChecks = checks.filter((c) => c.fix && c.status !== "pass");
     if (fixChecks.length === 0)
         return;
-    const fixOptions = fixChecks.map(c => {
+    const fixOptions = fixChecks.map((c) => {
         const cmd = c.fix.replace(/^Run:\s*/, "");
         return { value: cmd, label: `Run: ${cmd}`, hint: c.name };
     });
@@ -677,7 +701,7 @@ async function checkHealth() {
     if (fixAction !== "__skip") {
         const cmd = fixAction;
         const SAFE_PREFIXES = ["arcana ", "git config "];
-        if (!SAFE_PREFIXES.some(pre => cmd.startsWith(pre))) {
+        if (!SAFE_PREFIXES.some((pre) => cmd.startsWith(pre))) {
             p.log.warn(`Skipped unsafe command: ${cmd}`);
         }
         else {
@@ -724,7 +748,7 @@ export async function showInteractiveMenu(version) {
     const config = loadConfig();
     const providerName = config.defaultProvider;
     // Fetch skill list once for the session
-    let allSkills = [];
+    const allSkills = [];
     let availableCount = 0;
     try {
         const providers = getProviders();
@@ -815,4 +839,3 @@ export async function showInteractiveMenu(version) {
         }
     }
 }
-//# sourceMappingURL=interactive.js.map

package/dist/providers/arcana.d.ts

@@ -2,4 +2,3 @@ import { GitHubProvider } from "./github.js";
 export declare class ArcanaProvider extends GitHubProvider {
     constructor();
 }
-//# sourceMappingURL=arcana.d.ts.map

package/dist/providers/arcana.js

@@ -8,4 +8,3 @@ export class ArcanaProvider extends GitHubProvider {
         });
     }
 }
-//# sourceMappingURL=arcana.js.map

package/dist/providers/base.d.ts

@@ -8,4 +8,3 @@ export declare abstract class Provider {
     clearCache(): void;
     info(skillName: string): Promise<SkillInfo | null>;
 }
-//# sourceMappingURL=base.d.ts.map

package/dist/providers/base.js

@@ -7,4 +7,3 @@ export class Provider {
         return skills.find((s) => s.name === skillName) ?? null;
     }
 }
-//# sourceMappingURL=base.js.map

package/dist/providers/github.d.ts

@@ -22,4 +22,3 @@ export declare class GitHubProvider extends Provider {
     search(query: string): Promise<SkillInfo[]>;
     clearCache(): void;
 }
-//# sourceMappingURL=github.d.ts.map

package/dist/providers/github.js

@@ -81,6 +81,11 @@ export class GitHubProvider extends Provider {
             version: p.version,
             source: this.name,
             repo: `https://github.com/${this.owner}/${this.repo}`,
+            tags: p.tags,
+            conflicts: p.conflicts,
+            companions: p.companions,
+            verified: p.verified,
+            author: p.author,
         }));
         // Warn about malformed entries
         const skipped = data.plugins.length - this.cache.length;
@@ -119,7 +124,7 @@ export class GitHubProvider extends Provider {
                 return { path: relativePath, content };
             }
             catch (err) {
-                throw new Error(`Failed to fetch file "${relativePath}" for skill "${skillName}": ${err instanceof Error ? err.message : String(err)}`);
+                throw new Error(`Failed to fetch file "${relativePath}" for skill "${skillName}": ${err instanceof Error ? err.message : String(err)}`, { cause: err });
             }
         }, 6);
         return results.filter((r) => r !== null);
@@ -128,7 +133,8 @@ export class GitHubProvider extends Provider {
         const all = await this.list();
         const q = query.toLowerCase();
         const exact = all.filter((s) => s.name.toLowerCase().includes(q) ||
-            s.description.toLowerCase().includes(q));
+            s.description.toLowerCase().includes(q) ||
+            s.tags?.some((t) => t.toLowerCase().includes(q)));
         if (exact.length > 0)
             return exact;
         // Fuzzy fallback: match skills where Levenshtein distance to name <= 3
@@ -143,4 +149,3 @@ export class GitHubProvider extends Provider {
         clearCacheFile(this.cacheKey);
     }
 }
-//# sourceMappingURL=github.js.map