@sporesec/arcana 2.4.0 → 3.0.1

package/dist/interactive/manage.js

@@ -0,0 +1,187 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import semver from "semver";
+import { isSkillInstalled, readSkillMeta, installSkill, writeSkillMeta } from "../utils/fs.js";
+import { getProvider } from "../registry.js";
+import { ui } from "../utils/ui.js";
+import { updateLockEntry } from "../utils/integrity.js";
+import { handleCancel, getInstalledNames } from "./helpers.js";
+import { SKILL_CATEGORIES } from "./categories.js";
+import { skillDetailFlow, doUninstall } from "./skill-detail.js";
+export async function manageInstalled(allSkills, providerName) {
+    while (true) {
+        const names = getInstalledNames();
+        if (names.length === 0) {
+            p.log.info("No skills installed.");
+            return;
+        }
+        // Group installed skills by category
+        const groups = [];
+        const categorized = new Set();
+        for (const [cat, catSkills] of Object.entries(SKILL_CATEGORIES)) {
+            const installed = catSkills.filter((s) => names.includes(s));
+            if (installed.length > 0) {
+                groups.push({ cat, skills: installed });
+                installed.forEach((s) => categorized.add(s));
+            }
+        }
+        const uncategorized = names.filter((s) => !categorized.has(s));
+        if (uncategorized.length > 0) {
+            groups.push({ cat: "Other", skills: uncategorized });
+        }
+        const options = groups.map((g) => ({
+            value: g.cat,
+            label: g.cat,
+            hint: `${g.skills.length} installed`,
+        }));
+        const picked = await p.select({
+            message: `Installed skills (${names.length})`,
+            options: [
+                ...options,
+                { value: "__update", label: chalk.cyan("Check for updates") },
+                { value: "__bulk_uninstall", label: "Uninstall multiple..." },
+                { value: "__back", label: "Back" },
+            ],
+        });
+        handleCancel(picked);
+        if (picked === "__back")
+            return;
+        if (picked === "__update") {
+            await updateAll(providerName);
+            continue;
+        }
+        if (picked === "__bulk_uninstall") {
+            await bulkUninstall(names);
+            continue;
+        }
+        const group = groups.find((g) => g.cat === picked);
+        if (group) {
+            await installedCategoryList(group.cat, group.skills, allSkills, providerName);
+        }
+    }
+}
+async function installedCategoryList(categoryName, installedNames, allSkills, providerName) {
+    while (true) {
+        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 meta = readSkillMeta(name);
+            const ver = meta ? `v${meta.version}` : "";
+            const date = meta?.installedAt ? new Date(meta.installedAt).toLocaleDateString() : "";
+            return {
+                value: name,
+                label: name,
+                hint: `${ver}${date ? `  ${date}` : ""}`,
+            };
+        });
+        const picked = await p.select({
+            message: `${categoryName} (${stillInstalled.length} installed)`,
+            options: [...options, { value: "__back", label: "Back" }],
+        });
+        handleCancel(picked);
+        if (picked === "__back")
+            return;
+        const result = await skillDetailFlow(picked, allSkills, providerName);
+        if (result === "menu")
+            return;
+    }
+}
+async function bulkUninstall(installedNames) {
+    const selected = await p.multiselect({
+        message: "Select skills to uninstall",
+        options: installedNames.map((name) => ({ value: name, label: name })),
+        required: false,
+        maxItems: 15,
+    });
+    handleCancel(selected);
+    const names = selected;
+    if (names.length === 0)
+        return;
+    const ok = await p.confirm({
+        message: `Uninstall ${names.length} skill${names.length > 1 ? "s" : ""}?`,
+    });
+    handleCancel(ok);
+    if (!ok)
+        return;
+    let removed = 0;
+    for (const name of names) {
+        if (doUninstall(name))
+            removed++;
+    }
+    p.log.success(`Removed ${removed} skill${removed !== 1 ? "s" : ""}`);
+}
+async function updateAll(providerName) {
+    const installed = getInstalledNames();
+    if (installed.length === 0) {
+        p.log.info("No skills installed.");
+        return;
+    }
+    const s = p.spinner();
+    s.start(`Checking ${installed.length} skill${installed.length !== 1 ? "s" : ""} for updates...`);
+    const provider = getProvider(providerName);
+    let remoteSkills;
+    try {
+        remoteSkills = await provider.list();
+    }
+    catch (err) {
+        s.stop("Failed to fetch remote skill list");
+        if (err instanceof Error)
+            p.log.error(ui.dim(err.message));
+        return;
+    }
+    const remoteMap = new Map(remoteSkills.map((rs) => [rs.name, rs]));
+    const updates = [];
+    for (const name of installed) {
+        const remote = remoteMap.get(name);
+        if (!remote)
+            continue;
+        const meta = readSkillMeta(name);
+        const localVer = semver.valid(semver.coerce(meta?.version)) ?? "0.0.0";
+        const remoteVer = semver.valid(semver.coerce(remote.version)) ?? "0.0.0";
+        if (semver.gt(remoteVer, localVer)) {
+            updates.push({ name, from: meta?.version ?? "0.0.0", to: remote.version });
+        }
+    }
+    s.stop(`Checked ${installed.length} skills`);
+    if (updates.length === 0) {
+        p.log.success("All skills are up to date.");
+        return;
+    }
+    p.log.step(`${updates.length} update${updates.length !== 1 ? "s" : ""} available:`);
+    for (const u of updates) {
+        p.log.info(`  ${chalk.bold(u.name)}: v${u.from} -> v${u.to}`);
+    }
+    const ok = await p.confirm({ message: "Apply updates?" });
+    handleCancel(ok);
+    if (!ok)
+        return;
+    const spin = p.spinner();
+    spin.start("Updating...");
+    let updated = 0;
+    for (const u of updates) {
+        try {
+            spin.message(`Updating ${chalk.bold(u.name)}...`);
+            const files = await provider.fetch(u.name);
+            installSkill(u.name, files);
+            const remote = remoteMap.get(u.name);
+            writeSkillMeta(u.name, {
+                version: remote.version,
+                installedAt: new Date().toISOString(),
+                source: providerName,
+                description: remote.description,
+                fileCount: files.length,
+                sizeBytes: files.reduce((s2, f) => s2 + f.content.length, 0),
+            });
+            updateLockEntry(u.name, remote.version, providerName, files);
+            updated++;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                p.log.error(`Failed to update ${u.name}: ${err.message}`);
+        }
+    }
+    spin.stop(`Updated ${updated} skill${updated !== 1 ? "s" : ""}`);
+}

package/dist/interactive/menu.d.ts

@@ -0,0 +1 @@
+export declare function showInteractiveMenu(version: string): Promise<void>;

package/dist/interactive/menu.js

@@ -0,0 +1,107 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { renderBanner } from "../utils/help.js";
+import { loadConfig } from "../utils/config.js";
+import { getProviders, clearProviderCache } from "../registry.js";
+import { getCliReference } from "../command-registry.js";
+import { AMBER, countInstalled, buildMenuOptions } from "./helpers.js";
+import { SKILL_CATEGORIES } from "./categories.js";
+import { browseByCategory } from "./browse.js";
+import { searchFlow } from "./search.js";
+import { quickSetup } from "./setup.js";
+import { manageInstalled } from "./manage.js";
+import { checkHealth } from "./health.js";
+export async function showInteractiveMenu(version) {
+    const config = loadConfig();
+    const providerName = config.defaultProvider;
+    // Fetch skill list once for the session
+    const allSkills = [];
+    let availableCount = 0;
+    try {
+        const providers = getProviders();
+        for (const provider of providers) {
+            const skills = await provider.list();
+            allSkills.push(...skills);
+        }
+        availableCount = allSkills.length;
+    }
+    catch {
+        // Offline mode
+    }
+    // Banner (shown once)
+    const installedOnEntry = countInstalled();
+    console.log();
+    console.log(renderBanner());
+    console.log();
+    console.log(`  ${AMBER.bold("arcana")} ${chalk.dim(`v${version}`)}`);
+    console.log(`  ${chalk.dim("Expert skills for AI coding agents. Install what you need.")}`);
+    console.log();
+    if (availableCount > 0 && installedOnEntry > 0) {
+        if (installedOnEntry > availableCount) {
+            console.log(`  ${chalk.dim(`${installedOnEntry} installed (${availableCount} in marketplace) | provider: ${providerName}`)}`);
+        }
+        else {
+            const pct = Math.round((installedOnEntry / availableCount) * 100);
+            console.log(`  ${chalk.dim(`${installedOnEntry}/${availableCount} installed (${pct}%) | provider: ${providerName}`)}`);
+        }
+    }
+    else if (availableCount > 0) {
+        console.log(`  ${chalk.dim(`${availableCount} skills across ${Object.keys(SKILL_CATEGORIES).length} categories`)}`);
+    }
+    else {
+        console.log(`  ${chalk.dim(`${installedOnEntry} installed | offline mode`)}`);
+    }
+    console.log();
+    // First-time guided setup
+    if (installedOnEntry === 0 && availableCount > 0) {
+        const wantsSetup = await p.confirm({
+            message: "First time? Let's find the right skills for your project.",
+            initialValue: true,
+        });
+        if (!p.isCancel(wantsSetup) && wantsSetup) {
+            await quickSetup(allSkills, providerName);
+        }
+    }
+    // Main loop
+    while (true) {
+        const installedCount = countInstalled();
+        const options = buildMenuOptions(installedCount, availableCount);
+        const selected = await p.select({
+            message: "What would you like to do?",
+            options,
+        });
+        if (p.isCancel(selected) || selected === "exit") {
+            clearProviderCache();
+            p.outro(chalk.dim("Until next time."));
+            return;
+        }
+        console.log();
+        try {
+            switch (selected) {
+                case "browse":
+                    await browseByCategory(allSkills, providerName);
+                    break;
+                case "search":
+                    await searchFlow(allSkills, providerName);
+                    break;
+                case "setup":
+                    await quickSetup(allSkills, providerName);
+                    break;
+                case "installed":
+                    await manageInstalled(allSkills, providerName);
+                    break;
+                case "health":
+                    await checkHealth();
+                    break;
+                case "ref":
+                    p.note(getCliReference(), "CLI Reference");
+                    break;
+            }
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                p.log.error(err.message);
+            }
+        }
+    }
+}

package/dist/interactive/search.d.ts

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

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