@sporesec/arcana 2.3.1 → 3.0.0

package/dist/commands/profile.js

@@ -0,0 +1,274 @@
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { atomicWriteSync } from "../utils/atomic.js";
+import { validateSlug } from "../utils/validate.js";
+function getProfilesPath() {
+    return join(homedir(), ".arcana", "profiles.json");
+}
+function readProfiles() {
+    const path = getProfilesPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeProfiles(profiles) {
+    const dir = join(homedir(), ".arcana");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    atomicWriteSync(getProfilesPath(), JSON.stringify(profiles, null, 2) + "\n");
+}
+export async function profileCommand(action, name, skills, opts) {
+    const resolved = action ?? "list";
+    switch (resolved) {
+        case "list":
+            return listProfiles(opts.json);
+        case "create":
+            return createProfile(name, skills, opts.json);
+        case "delete":
+            return deleteProfile(name, opts.json);
+        case "show":
+            return showProfile(name, opts.json);
+        case "apply":
+            return applyProfile(name, opts.json);
+        default:
+            console.error(`Unknown action: ${resolved}`);
+            console.error("Valid actions: list, create, delete, show, apply");
+            process.exit(1);
+    }
+}
+function listProfiles(json) {
+    const profiles = readProfiles();
+    const names = Object.keys(profiles);
+    if (json) {
+        console.log(JSON.stringify({ profiles }));
+        return;
+    }
+    if (names.length === 0) {
+        console.log("No profiles defined.");
+        console.log("Create one: arcana profile create <name> <skill1> <skill2> ...");
+        return;
+    }
+    console.log(`${names.length} profile(s):\n`);
+    for (const profileName of names) {
+        const skillList = profiles[profileName];
+        console.log(`  ${profileName.padEnd(20)} ${skillList.length} skill(s): ${skillList.join(", ")}`);
+    }
+    console.log();
+}
+function createProfile(name, skills, json) {
+    if (!name) {
+        if (json) {
+            console.log(JSON.stringify({ error: "Profile name is required" }));
+        }
+        else {
+            console.error("Profile name is required.");
+            console.error("Usage: arcana profile create <name> <skill1> <skill2> ...");
+        }
+        process.exit(1);
+    }
+    try {
+        validateSlug(name, "profile name");
+    }
+    catch (err) {
+        if (json) {
+            console.log(JSON.stringify({ error: err instanceof Error ? err.message : "Invalid profile name" }));
+        }
+        else {
+            console.error(err instanceof Error ? err.message : "Invalid profile name");
+        }
+        process.exit(1);
+    }
+    if (skills.length === 0) {
+        if (json) {
+            console.log(JSON.stringify({ error: "At least one skill is required" }));
+        }
+        else {
+            console.error("At least one skill is required.");
+            console.error("Usage: arcana profile create <name> <skill1> <skill2> ...");
+        }
+        process.exit(1);
+    }
+    for (const skill of skills) {
+        try {
+            validateSlug(skill, "skill name");
+        }
+        catch (err) {
+            if (json) {
+                console.log(JSON.stringify({ error: err instanceof Error ? err.message : `Invalid skill name: ${skill}` }));
+            }
+            else {
+                console.error(err instanceof Error ? err.message : `Invalid skill name: ${skill}`);
+            }
+            process.exit(1);
+        }
+    }
+    const profiles = readProfiles();
+    if (profiles[name]) {
+        if (json) {
+            console.log(JSON.stringify({ error: `Profile "${name}" already exists` }));
+        }
+        else {
+            console.error(`Profile "${name}" already exists. Delete it first or choose a different name.`);
+        }
+        process.exit(1);
+    }
+    profiles[name] = skills;
+    writeProfiles(profiles);
+    if (json) {
+        console.log(JSON.stringify({ created: name, skills }));
+    }
+    else {
+        console.log(`Created profile "${name}" with ${skills.length} skill(s): ${skills.join(", ")}`);
+    }
+}
+function deleteProfile(name, json) {
+    if (!name) {
+        if (json) {
+            console.log(JSON.stringify({ error: "Profile name is required" }));
+        }
+        else {
+            console.error("Profile name is required.");
+            console.error("Usage: arcana profile delete <name>");
+        }
+        process.exit(1);
+    }
+    const profiles = readProfiles();
+    if (!profiles[name]) {
+        if (json) {
+            console.log(JSON.stringify({ error: `Profile "${name}" not found` }));
+        }
+        else {
+            console.error(`Profile "${name}" not found.`);
+        }
+        process.exit(1);
+    }
+    delete profiles[name];
+    writeProfiles(profiles);
+    if (json) {
+        console.log(JSON.stringify({ deleted: name }));
+    }
+    else {
+        console.log(`Deleted profile "${name}".`);
+    }
+}
+function showProfile(name, json) {
+    if (!name) {
+        if (json) {
+            console.log(JSON.stringify({ error: "Profile name is required" }));
+        }
+        else {
+            console.error("Profile name is required.");
+            console.error("Usage: arcana profile show <name>");
+        }
+        process.exit(1);
+    }
+    const profiles = readProfiles();
+    const skills = profiles[name];
+    if (!skills) {
+        if (json) {
+            console.log(JSON.stringify({ error: `Profile "${name}" not found` }));
+        }
+        else {
+            console.error(`Profile "${name}" not found.`);
+        }
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ name, skills }));
+    }
+    else {
+        console.log(`Profile "${name}" (${skills.length} skill(s)):\n`);
+        for (const skill of skills) {
+            console.log(`  - ${skill}`);
+        }
+        console.log();
+    }
+}
+async function applyProfile(name, json) {
+    if (!name) {
+        if (json) {
+            console.log(JSON.stringify({ error: "Profile name is required" }));
+        }
+        else {
+            console.error("Profile name is required.");
+            console.error("Usage: arcana profile apply <name>");
+        }
+        process.exit(1);
+    }
+    const profiles = readProfiles();
+    const skills = profiles[name];
+    if (!skills) {
+        if (json) {
+            console.log(JSON.stringify({ error: `Profile "${name}" not found` }));
+        }
+        else {
+            console.error(`Profile "${name}" not found.`);
+        }
+        process.exit(1);
+    }
+    if (skills.length === 0) {
+        if (json) {
+            console.log(JSON.stringify({ applied: name, installed: [], skipped: [], failed: [] }));
+        }
+        else {
+            console.log(`Profile "${name}" has no skills.`);
+        }
+        return;
+    }
+    const { getProvider } = await import("../registry.js");
+    const { installSkill, writeSkillMeta, isSkillInstalled } = await import("../utils/fs.js");
+    const { loadConfig } = await import("../utils/config.js");
+    const config = loadConfig();
+    const provider = getProvider(config.defaultProvider);
+    const installed = [];
+    const skipped = [];
+    const failed = [];
+    for (const skillName of skills) {
+        if (isSkillInstalled(skillName)) {
+            skipped.push(skillName);
+            continue;
+        }
+        try {
+            const files = await provider.fetch(skillName);
+            installSkill(skillName, files);
+            const remote = await provider.info(skillName);
+            writeSkillMeta(skillName, {
+                version: remote?.version ?? "0.0.0",
+                installedAt: new Date().toISOString(),
+                source: provider.name,
+                description: remote?.description,
+                fileCount: files.length,
+                sizeBytes: files.reduce((s, f) => s + f.content.length, 0),
+            });
+            installed.push(skillName);
+        }
+        catch (err) {
+            failed.push(skillName);
+            if (!json && err instanceof Error) {
+                console.error(`  Failed to install ${skillName}: ${err.message}`);
+            }
+        }
+    }
+    if (json) {
+        console.log(JSON.stringify({ applied: name, installed, skipped, failed }));
+    }
+    else {
+        console.log(`Applied profile "${name}":`);
+        if (installed.length > 0)
+            console.log(`  Installed: ${installed.join(", ")}`);
+        if (skipped.length > 0)
+            console.log(`  Skipped (already installed): ${skipped.join(", ")}`);
+        if (failed.length > 0)
+            console.log(`  Failed: ${failed.join(", ")}`);
+        console.log();
+    }
+    if (failed.length > 0)
+        process.exit(1);
+}

package/dist/commands/providers.d.ts

@@ -3,4 +3,3 @@ export declare function providersCommand(opts: {
     remove?: string;
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=providers.d.ts.map

package/dist/commands/providers.js

@@ -87,9 +87,7 @@ export async function providersCommand(opts) {
     console.log(ui.bold("  Configured providers:"));
     console.log();
     const rows = config.providers.map((p) => [
-        p.name === config.defaultProvider
-            ? ui.brand(p.name) + ui.dim(" (default)")
-            : ui.bold(p.name),
+        p.name === config.defaultProvider ? ui.brand(p.name) + ui.dim(" (default)") : ui.bold(p.name),
         ui.dim(p.type),
         ui.dim(p.url),
         p.enabled ? ui.success("enabled") : ui.dim("disabled"),
@@ -100,4 +98,3 @@ export async function providersCommand(opts) {
     console.log(ui.dim("  Remove: arcana providers --remove name"));
     console.log();
 }
-//# sourceMappingURL=providers.js.map

package/dist/commands/recommend.d.ts

@@ -0,0 +1,5 @@
+export declare function recommendCommand(opts: {
+    json?: boolean;
+    limit?: number;
+    provider?: string;
+}): Promise<void>;

package/dist/commands/recommend.js

@@ -0,0 +1,96 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { detectProjectContext } from "../utils/project-context.js";
+import { rankSkills } from "../utils/scoring.js";
+import { getProviders } from "../registry.js";
+export async function recommendCommand(opts) {
+    const cwd = process.cwd();
+    const context = detectProjectContext(cwd);
+    if (!opts.json) {
+        p.intro(chalk.bold("Smart Recommendations"));
+        p.log.step(`Project: ${chalk.cyan(context.name)} (${context.type} / ${context.lang})`);
+        if (context.tags.length > 0) {
+            p.log.info(`Tags detected: ${context.tags.join(", ")}`);
+        }
+        if (context.ruleFiles.length > 0) {
+            p.log.info(`Rules found: ${context.ruleFiles.join(", ")}`);
+        }
+    }
+    // Fetch all skills from providers
+    const providers = getProviders(opts.provider);
+    const allSkills = [];
+    for (const prov of providers) {
+        try {
+            const skills = await prov.list();
+            allSkills.push(...skills);
+        }
+        catch (err) {
+            if (!opts.json) {
+                p.log.warn(`Could not fetch from ${prov.displayName}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    if (allSkills.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "No skills available" }));
+        }
+        else {
+            p.log.error("No skills available from any provider.");
+        }
+        process.exit(1);
+    }
+    // Score and rank
+    const verdicts = rankSkills(allSkills, context);
+    const limit = opts.limit ?? Infinity;
+    const recommended = verdicts.filter((v) => v.verdict === "recommended").slice(0, limit);
+    const optional = verdicts.filter((v) => v.verdict === "optional").slice(0, limit);
+    const conflicts = verdicts.filter((v) => v.verdict === "conflict");
+    const skipped = verdicts.filter((v) => v.verdict === "skip");
+    if (opts.json) {
+        const output = {
+            project: { name: context.name, type: context.type, lang: context.lang, tags: context.tags },
+            recommended: recommended.map(formatVerdict),
+            optional: optional.map(formatVerdict),
+            conflicts: conflicts.map(formatVerdict),
+            skippedCount: skipped.length,
+        };
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    // Display results
+    if (recommended.length > 0) {
+        console.log();
+        console.log(chalk.green.bold("  RECOMMENDED"));
+        for (const v of recommended) {
+            printVerdict(v);
+        }
+    }
+    if (optional.length > 0) {
+        console.log();
+        console.log(chalk.yellow.bold("  OPTIONAL"));
+        for (const v of optional) {
+            printVerdict(v);
+        }
+    }
+    if (conflicts.length > 0) {
+        console.log();
+        console.log(chalk.red.bold("  CONFLICTS"));
+        for (const v of conflicts) {
+            console.log(`    ${chalk.red(v.skill.padEnd(28))} ${chalk.red("!!")}   ${v.reasons.join(" | ")}`);
+        }
+    }
+    const skipCount = skipped.length;
+    if (skipCount > 0) {
+        console.log();
+        console.log(chalk.dim(`  ${skipCount} skill${skipCount === 1 ? "" : "s"} skipped (installed or no relevance)`));
+    }
+    console.log();
+    p.outro(`Install: ${chalk.cyan("arcana install <skill>")}`);
+}
+function printVerdict(v) {
+    const scoreStr = v.score > 0 ? `+${v.score}` : String(v.score);
+    console.log(`    ${chalk.bold(v.skill.padEnd(28))} ${chalk.cyan(scoreStr.padStart(4))}  ${chalk.dim(v.reasons.join(" | "))}`);
+}
+function formatVerdict(v) {
+    return { skill: v.skill, score: v.score, reasons: v.reasons };
+}

package/dist/commands/scan.d.ts

@@ -2,4 +2,3 @@ export declare function scanCommand(skill: string | undefined, opts: {
     all?: boolean;
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=scan.d.ts.map

package/dist/commands/scan.js

@@ -59,9 +59,9 @@ export async function scanCommand(skill, opts) {
             }
             else {
                 totalIssues += issues.length;
-                criticalCount += issues.filter(i => i.level === "critical").length;
-                highCount += issues.filter(i => i.level === "high").length;
-                mediumCount += issues.filter(i => i.level === "medium").length;
+                criticalCount += issues.filter((i) => i.level === "critical").length;
+                highCount += issues.filter((i) => i.level === "high").length;
+                mediumCount += issues.filter((i) => i.level === "medium").length;
             }
         }
         catch (err) {
@@ -70,11 +70,18 @@ export async function scanCommand(skill, opts) {
     }
     if (opts.json) {
         console.log(JSON.stringify({
-            summary: { total: skills.length, clean: cleanCount, issues: totalIssues, critical: criticalCount, high: highCount, medium: mediumCount },
-            results: results.map(r => ({
+            summary: {
+                total: skills.length,
+                clean: cleanCount,
+                issues: totalIssues,
+                critical: criticalCount,
+                high: highCount,
+                medium: mediumCount,
+            },
+            results: results.map((r) => ({
                 skill: r.skill,
                 ...(r.error ? { error: r.error } : {}),
-                issues: r.issues.map(i => ({ level: i.level, category: i.category, detail: i.detail, line: i.line })),
+                issues: r.issues.map((i) => ({ level: i.level, category: i.category, detail: i.detail, line: i.line })),
             })),
         }, null, 2));
         if (criticalCount > 0)
@@ -107,4 +114,3 @@ export async function scanCommand(skill, opts) {
     if (criticalCount > 0)
         process.exit(1);
 }
-//# sourceMappingURL=scan.js.map

package/dist/commands/search.d.ts

@@ -2,5 +2,6 @@ export declare function searchCommand(query: string, opts: {
     provider?: string;
     cache?: boolean;
     json?: boolean;
+    tag?: string;
+    smart?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=search.d.ts.map

package/dist/commands/search.js

@@ -1,6 +1,7 @@
 import { ui, banner, spinner, noopSpinner, table, printErrorWithHint } from "../utils/ui.js";
 import { isSkillInstalled } from "../utils/fs.js";
 import { getProviders } from "../registry.js";
+import { detectProjectContext } from "../utils/project-context.js";
 export async function searchCommand(query, opts) {
     if (!opts.json)
         banner();
@@ -11,15 +12,13 @@ export async function searchCommand(query, opts) {
     }
     const s = opts.json ? noopSpinner() : spinner(`Searching for "${query}"...`);
     s.start();
-    const results = [];
+    let results = [];
     try {
         for (const provider of providers) {
             const skills = await provider.search(query);
             for (const skill of skills) {
                 results.push({
-                    name: skill.name,
-                    description: skill.description,
-                    source: skill.source,
+                    ...skill,
                     installed: isSkillInstalled(skill.name),
                 });
             }
@@ -34,20 +33,45 @@ export async function searchCommand(query, opts) {
         printErrorWithHint(err, true);
         process.exit(1);
     }
+    // Filter by tag
+    if (opts.tag) {
+        const tag = opts.tag.toLowerCase();
+        results = results.filter((r) => r.tags?.some((t) => t.toLowerCase() === tag));
+    }
+    // Smart ranking: boost results matching project context
+    if (opts.smart) {
+        const context = detectProjectContext(process.cwd());
+        results.sort((a, b) => {
+            const aScore = (a.tags ?? []).filter((t) => context.tags.includes(t)).length;
+            const bScore = (b.tags ?? []).filter((t) => context.tags.includes(t)).length;
+            return bScore - aScore;
+        });
+    }
     s.stop();
     if (opts.json) {
-        console.log(JSON.stringify({ query, results }, null, 2));
+        console.log(JSON.stringify({
+            query,
+            results: results.map((r) => ({
+                name: r.name,
+                description: r.description,
+                source: r.source,
+                installed: r.installed,
+                tags: r.tags,
+                verified: r.verified,
+            })),
+        }, null, 2));
         return;
     }
     if (results.length === 0) {
-        console.log(ui.dim(`  No skills matching "${query}"`));
+        console.log(ui.dim(`  No skills matching "${query}"${opts.tag ? ` with tag "${opts.tag}"` : ""}`));
     }
     else {
         console.log(ui.bold(`  ${results.length} results for "${query}":`));
         console.log();
         const rows = results.map((r) => [
-            ui.bold(r.name),
-            r.description.slice(0, 80) + (r.description.length > 80 ? "..." : ""),
+            ui.bold(r.name) + (r.verified ? " " + ui.success("[V]") : ""),
+            r.description.slice(0, 60) + (r.description.length > 60 ? "..." : ""),
+            r.tags?.slice(0, 3).join(", ") ?? "",
             ui.dim(r.source),
             r.installed ? ui.success("[installed]") : "",
         ]);
@@ -55,4 +79,3 @@ export async function searchCommand(query, opts) {
     }
     console.log();
 }
-//# sourceMappingURL=search.js.map

package/dist/commands/stats.d.ts

@@ -1,4 +1,3 @@
 export declare function statsCommand(opts: {
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=stats.d.ts.map