@sporesec/arcana 2.4.0 → 3.0.0

package/dist/commands/lock.js

@@ -0,0 +1,171 @@
+import { readdirSync, readFileSync, existsSync, lstatSync } from "node:fs";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { getInstallDir, readSkillMeta } from "../utils/fs.js";
+import { readLockfile, writeLockfile, computeHash } from "../utils/integrity.js";
+import { renderBanner } from "../utils/help.js";
+import { printErrorWithHint } from "../utils/ui.js";
+function readSkillFiles(skillDir) {
+    const files = [];
+    const queue = [skillDir];
+    while (queue.length > 0) {
+        const dir = queue.pop();
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            const stat = lstatSync(full);
+            if (stat.isDirectory())
+                queue.push(full);
+            else if (stat.isFile()) {
+                const relPath = full.slice(skillDir.length + 1).replace(/\\/g, "/");
+                files.push({ path: relPath, content: readFileSync(full, "utf-8") });
+            }
+        }
+    }
+    return files;
+}
+export async function lockCommand(opts) {
+    if (opts.ci) {
+        return ciMode(opts.json);
+    }
+    return generateMode(opts.json);
+}
+async function generateMode(json) {
+    if (!json) {
+        console.log(renderBanner());
+        console.log();
+        p.intro(chalk.bold("Generate lockfile"));
+    }
+    const installDir = getInstallDir();
+    if (!existsSync(installDir)) {
+        if (json) {
+            console.log(JSON.stringify({ action: "generate", entries: 0, path: "~/.arcana/arcana-lock.json" }));
+        }
+        else {
+            p.log.info("No skills installed. Lockfile written with 0 entries.");
+        }
+        writeLockfile([]);
+        return;
+    }
+    const dirs = readdirSync(installDir).filter((d) => {
+        try {
+            return lstatSync(join(installDir, d)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    const entries = [];
+    for (const name of dirs) {
+        const skillDir = join(installDir, name);
+        const files = readSkillFiles(skillDir);
+        const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+        const concatenated = sorted.map((f) => f.content).join("");
+        const hash = computeHash(concatenated);
+        const meta = readSkillMeta(name);
+        entries.push({
+            skill: name,
+            version: meta?.version ?? "0.0.0",
+            hash,
+            source: meta?.source ?? "unknown",
+            installedAt: meta?.installedAt ?? new Date().toISOString(),
+        });
+    }
+    writeLockfile(entries);
+    if (json) {
+        console.log(JSON.stringify({ action: "generate", entries: entries.length, path: "~/.arcana/arcana-lock.json" }));
+    }
+    else {
+        p.log.success(`Lockfile written with ${entries.length} entries.`);
+        p.outro(chalk.dim("~/.arcana/arcana-lock.json"));
+    }
+}
+async function ciMode(json) {
+    if (!json) {
+        console.log(renderBanner());
+        console.log();
+        p.intro(chalk.bold("Validate lockfile"));
+    }
+    const existing = readLockfile();
+    if (existing.length === 0) {
+        const lockPath = join(getInstallDir(), "..", "arcana-lock.json");
+        if (!existsSync(lockPath)) {
+            if (json) {
+                console.log(JSON.stringify({
+                    action: "ci",
+                    valid: false,
+                    mismatches: [],
+                    missing: [],
+                    extra: [],
+                    error: "No lockfile found",
+                }));
+            }
+            else {
+                printErrorWithHint(new Error("No lockfile found. Run `arcana lock` first to generate one."), true);
+            }
+            process.exit(1);
+        }
+    }
+    const installDir = getInstallDir();
+    const installedDirs = existsSync(installDir)
+        ? readdirSync(installDir).filter((d) => {
+            try {
+                return lstatSync(join(installDir, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+        : [];
+    const lockedNames = new Set(existing.map((e) => e.skill));
+    const installedNames = new Set(installedDirs);
+    const mismatches = [];
+    const missing = [];
+    const extra = [];
+    // Check each lockfile entry against installed state
+    for (const entry of existing) {
+        if (!installedNames.has(entry.skill)) {
+            missing.push(entry.skill);
+            continue;
+        }
+        const skillDir = join(installDir, entry.skill);
+        const files = readSkillFiles(skillDir);
+        const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+        const concatenated = sorted.map((f) => f.content).join("");
+        const hash = computeHash(concatenated);
+        if (hash !== entry.hash) {
+            mismatches.push(entry.skill);
+        }
+    }
+    // Check for extra skills not in lockfile
+    for (const name of installedDirs) {
+        if (!lockedNames.has(name)) {
+            extra.push(name);
+        }
+    }
+    const valid = mismatches.length === 0 && missing.length === 0 && extra.length === 0;
+    if (json) {
+        console.log(JSON.stringify({ action: "ci", valid, mismatches, missing, extra }));
+    }
+    else {
+        if (valid) {
+            p.log.success("Lockfile matches installed state.");
+            p.outro(chalk.dim("All entries verified."));
+        }
+        else {
+            if (mismatches.length > 0) {
+                p.log.error(`Hash mismatch: ${mismatches.join(", ")}`);
+            }
+            if (missing.length > 0) {
+                p.log.error(`Missing from disk: ${missing.join(", ")}`);
+            }
+            if (extra.length > 0) {
+                p.log.warn(`Extra (not in lockfile): ${extra.join(", ")}`);
+            }
+            p.outro(chalk.dim("Lockfile validation failed."));
+        }
+    }
+    if (!valid) {
+        process.exit(1);
+    }
+}

package/dist/commands/optimize.d.ts

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

package/dist/commands/optimize.js

@@ -17,19 +17,39 @@ function readSettings() {
 function checkAutocompact() {
     const settings = readSettings();
     if (!settings) {
-        return { area: "Autocompact", status: "suggest", message: "No settings.json found", action: "Set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=80 in ~/.claude/settings.json env block" };
+        return {
+            area: "Autocompact",
+            status: "suggest",
+            message: "No settings.json found",
+            action: "Set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=80 in ~/.claude/settings.json env block",
+        };
     }
     const env = settings.env;
     const val = env?.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE;
     if (!val) {
-        return { area: "Autocompact", status: "suggest", message: "Not configured (defaults to high threshold)", action: "Set to 80 to compact earlier and save tokens" };
+        return {
+            area: "Autocompact",
+            status: "suggest",
+            message: "Not configured (defaults to high threshold)",
+            action: "Set to 80 to compact earlier and save tokens",
+        };
     }
     const pct = parseInt(val);
     if (pct <= 70) {
-        return { area: "Autocompact", status: "warn", message: `Set to ${pct}%. Too aggressive, may lose context.`, action: "Raise to 75-80% for better balance" };
+        return {
+            area: "Autocompact",
+            status: "warn",
+            message: `Set to ${pct}%. Too aggressive, may lose context.`,
+            action: "Raise to 75-80% for better balance",
+        };
     }
     if (pct > 85) {
-        return { area: "Autocompact", status: "suggest", message: `Set to ${pct}%. Compaction happens late, less room for reasoning.`, action: "Lower to 80% for better quality (research-backed)" };
+        return {
+            area: "Autocompact",
+            status: "suggest",
+            message: `Set to ${pct}%. Compaction happens late, less room for reasoning.`,
+            action: "Lower to 80% for better quality (research-backed)",
+        };
     }
     return { area: "Autocompact", status: "good", message: `Set to ${pct}% (optimal range)` };
 }
@@ -41,7 +61,12 @@ function checkEffortLevel() {
         return { area: "Effort level", status: "good", message: "Using default (high)" };
     }
     if (val === "low") {
-        return { area: "Effort level", status: "suggest", message: "Set to 'low'. Faster but may miss details.", action: "Use 'medium' for daily work, 'high' for complex tasks" };
+        return {
+            area: "Effort level",
+            status: "suggest",
+            message: "Set to 'low'. Faster but may miss details.",
+            action: "Use 'medium' for daily work, 'high' for complex tasks",
+        };
     }
     if (val === "medium") {
         return { area: "Effort level", status: "good", message: "Set to 'medium'. Good balance of speed and quality." };
@@ -55,7 +80,12 @@ function checkNonEssentialCalls() {
     if (val === "1" || val === "true") {
         return { area: "Non-essential calls", status: "good", message: "Disabled (saves tokens)" };
     }
-    return { area: "Non-essential calls", status: "suggest", message: "Not disabled", action: "Set DISABLE_NON_ESSENTIAL_MODEL_CALLS=1 in settings.json env to save tokens" };
+    return {
+        area: "Non-essential calls",
+        status: "suggest",
+        message: "Not disabled",
+        action: "Set DISABLE_NON_ESSENTIAL_MODEL_CALLS=1 in settings.json env to save tokens",
+    };
 }
 function checkSkillTokenBudget() {
     const dir = getInstallDir();
@@ -78,7 +108,10 @@ function checkSkillTokenBudget() {
     const estTokens = Math.round(totalKB * 256);
     if (totalKB > 500) {
         large.sort((a, b) => b.kb - a.kb);
-        const topNames = large.slice(0, 3).map(s => s.name).join(", ");
+        const topNames = large
+            .slice(0, 3)
+            .map((s) => s.name)
+            .join(", ");
         return {
             area: "Skill token budget",
             status: "warn",
@@ -94,7 +127,11 @@ function checkSkillTokenBudget() {
             action: "Review installed skills with 'arcana list --installed' and remove unused ones",
         };
     }
-    return { area: "Skill token budget", status: "good", message: `${skillCount} skills, ${totalKB.toFixed(0)} KB (~${(estTokens / 1000).toFixed(0)}K tokens)` };
+    return {
+        area: "Skill token budget",
+        status: "good",
+        message: `${skillCount} skills, ${totalKB.toFixed(0)} KB (~${(estTokens / 1000).toFixed(0)}K tokens)`,
+    };
 }
 function checkDiskHealth() {
     const claudeDir = join(homedir(), ".claude");
@@ -103,19 +140,26 @@ function checkDiskHealth() {
     }
     const totalMB = getDirSize(claudeDir) / (1024 * 1024);
     if (totalMB > 1000) {
-        return { area: "Disk health", status: "warn", message: `${totalMB.toFixed(0)} MB total Claude data`, action: "Run: arcana compact (removes agent logs, keeps sessions)" };
+        return {
+            area: "Disk health",
+            status: "warn",
+            message: `${totalMB.toFixed(0)} MB total Claude data`,
+            action: "Run: arcana compact (removes agent logs, keeps sessions)",
+        };
     }
     if (totalMB > 500) {
-        return { area: "Disk health", status: "suggest", message: `${totalMB.toFixed(0)} MB total Claude data`, action: "Run: arcana compact" };
+        return {
+            area: "Disk health",
+            status: "suggest",
+            message: `${totalMB.toFixed(0)} MB total Claude data`,
+            action: "Run: arcana compact",
+        };
     }
     return { area: "Disk health", status: "good", message: `${totalMB.toFixed(0)} MB total Claude data` };
 }
 function checkPreCompactHook() {
     // Check both global and local settings for PreCompact hooks
-    const paths = [
-        join(homedir(), ".claude", "settings.json"),
-        join(homedir(), ".claude", "settings.local.json"),
-    ];
+    const paths = [join(homedir(), ".claude", "settings.json"), join(homedir(), ".claude", "settings.local.json")];
     for (const settingsPath of paths) {
         if (!existsSync(settingsPath))
             continue;
@@ -222,7 +266,56 @@ function checkAgentBloat() {
             action: "Run: arcana compact",
         };
     }
-    return { area: "Agent log bloat", status: "good", message: `${agentCount} agent logs (${agentMB.toFixed(0)} MB), ${mainCount} main sessions (${(mainBytes / (1024 * 1024)).toFixed(0)} MB)` };
+    return {
+        area: "Agent log bloat",
+        status: "good",
+        message: `${agentCount} agent logs (${agentMB.toFixed(0)} MB), ${mainCount} main sessions (${(mainBytes / (1024 * 1024)).toFixed(0)} MB)`,
+    };
+}
+function checkLargestSkills() {
+    const dir = getInstallDir();
+    if (!existsSync(dir)) {
+        return { area: "Top skills by size", status: "good", message: "No skills installed" };
+    }
+    const skills = [];
+    for (const entry of readdirSync(dir)) {
+        const skillDir = join(dir, entry);
+        if (!statSync(skillDir).isDirectory())
+            continue;
+        const kb = getDirSize(skillDir) / 1024;
+        skills.push({ name: entry, kb });
+    }
+    if (skills.length === 0) {
+        return { area: "Top skills by size", status: "good", message: "No skills installed" };
+    }
+    skills.sort((a, b) => b.kb - a.kb);
+    const totalKB = skills.reduce((s, sk) => s + sk.kb, 0);
+    const totalMB = totalKB / 1024;
+    const top5 = skills
+        .slice(0, 5)
+        .map((s) => `${s.name} (${s.kb.toFixed(0)} KB)`)
+        .join(", ");
+    if (totalMB > 3) {
+        return {
+            area: "Top skills by size",
+            status: "warn",
+            message: `${skills.length} skills, ${totalMB.toFixed(1)} MB total. Top 5: ${top5}`,
+            action: "Review large skills with 'arcana list --installed'. Uninstall unused ones.",
+        };
+    }
+    if (totalMB > 1.5) {
+        return {
+            area: "Top skills by size",
+            status: "suggest",
+            message: `${skills.length} skills, ${totalMB.toFixed(1)} MB total. Top 5: ${top5}`,
+            action: "Consider removing rarely used skills to save context tokens",
+        };
+    }
+    return {
+        area: "Top skills by size",
+        status: "good",
+        message: `${skills.length} skills, ${totalMB.toFixed(1)} MB total. Top 5: ${top5}`,
+    };
 }
 export async function optimizeCommand(opts) {
     if (!opts.json) {
@@ -238,21 +331,20 @@ export async function optimizeCommand(opts) {
         checkMemorySize(),
         checkAgentBloat(),
         checkDiskHealth(),
+        checkLargestSkills(),
     ];
     if (opts.json) {
         console.log(JSON.stringify({ recommendations }, null, 2));
         return;
     }
     for (const rec of recommendations) {
-        const icon = rec.status === "good" ? ui.success("[OK]")
-            : rec.status === "suggest" ? ui.cyan("[>>]")
-                : ui.warn("[!!]");
+        const icon = rec.status === "good" ? ui.success("[OK]") : rec.status === "suggest" ? ui.cyan("[>>]") : ui.warn("[!!]");
         console.log(`  ${icon} ${ui.bold(rec.area)}: ${rec.message}`);
         if (rec.action) {
             console.log(ui.dim(`      ${rec.action}`));
         }
     }
-    const actionable = recommendations.filter(r => r.status !== "good");
+    const actionable = recommendations.filter((r) => r.status !== "good");
     console.log();
     if (actionable.length === 0) {
         console.log(ui.success("  Your setup is well optimized."));
@@ -262,4 +354,3 @@ export async function optimizeCommand(opts) {
     }
     console.log();
 }
-//# sourceMappingURL=optimize.js.map

package/dist/commands/outdated.d.ts

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

package/dist/commands/outdated.js

@@ -0,0 +1,159 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import semver from "semver";
+import { getInstallDir, readSkillMeta } from "../utils/fs.js";
+import { getProvider, getProviders } from "../registry.js";
+import { loadConfig } from "../utils/config.js";
+function listInstalledSkills(installDir) {
+    if (!existsSync(installDir))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(installDir);
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+        const fullPath = join(installDir, entry);
+        try {
+            const stat = statSync(fullPath);
+            if (stat.isDirectory() && existsSync(join(fullPath, "SKILL.md"))) {
+                results.push(entry);
+            }
+        }
+        catch {
+            // skip unreadable
+        }
+    }
+    return results;
+}
+export async function outdatedCommand(opts) {
+    const installDir = getInstallDir();
+    const skills = listInstalledSkills(installDir);
+    if (skills.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ outdated: [], upToDate: 0, total: 0 }));
+        }
+        else {
+            console.log("No skills installed.");
+        }
+        process.exit(0);
+    }
+    const providerName = opts.provider ?? loadConfig().defaultProvider;
+    const providers = opts.provider ? [getProvider(providerName)] : getProviders();
+    if (providers.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({
+                error: "No providers configured",
+                outdated: [],
+                upToDate: 0,
+                total: 0,
+            }));
+        }
+        else {
+            console.error("No providers configured. Run: arcana providers --add owner/repo");
+        }
+        process.exit(0);
+    }
+    const outdated = [];
+    let upToDate = 0;
+    let checked = 0;
+    for (const skillName of skills) {
+        const meta = readSkillMeta(skillName);
+        const localVersion = meta?.version ?? "0.0.0";
+        const preferredSource = meta?.source;
+        // Try the provider that installed this skill first, then fall back to others
+        const orderedProviders = [...providers];
+        if (preferredSource) {
+            const idx = orderedProviders.findIndex((p) => p.name === preferredSource);
+            if (idx > 0) {
+                const [pref] = orderedProviders.splice(idx, 1);
+                orderedProviders.unshift(pref);
+            }
+        }
+        let found = false;
+        for (const provider of orderedProviders) {
+            try {
+                const remoteInfo = await provider.info(skillName);
+                if (!remoteInfo)
+                    continue;
+                const remoteVersion = remoteInfo.version;
+                const coercedRemote = semver.valid(semver.coerce(remoteVersion)) ?? "0.0.0";
+                const coercedLocal = semver.valid(semver.coerce(localVersion)) ?? "0.0.0";
+                if (semver.gt(coercedRemote, coercedLocal)) {
+                    outdated.push({
+                        name: skillName,
+                        current: localVersion,
+                        available: remoteVersion,
+                        source: provider.name,
+                    });
+                }
+                else {
+                    upToDate++;
+                }
+                found = true;
+                checked++;
+                break;
+            }
+            catch {
+                // try next provider
+            }
+        }
+        if (!found) {
+            // Could not check this skill, count it as up-to-date for totals
+            upToDate++;
+            checked++;
+        }
+    }
+    const result = {
+        outdated,
+        upToDate,
+        total: checked,
+    };
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        process.exit(0);
+    }
+    // Console output: aligned table
+    console.log(`Checked ${result.total} installed skills.`);
+    console.log();
+    if (outdated.length === 0) {
+        console.log("All skills are up to date.");
+        process.exit(0);
+    }
+    // Calculate column widths
+    const nameWidth = Math.max(4, ...outdated.map((e) => e.name.length));
+    const currentWidth = Math.max(7, ...outdated.map((e) => e.current.length));
+    const availableWidth = Math.max(9, ...outdated.map((e) => e.available.length));
+    const sourceWidth = Math.max(6, ...outdated.map((e) => e.source.length));
+    const header = "Name".padEnd(nameWidth) +
+        "  " +
+        "Current".padEnd(currentWidth) +
+        "  " +
+        "Available".padEnd(availableWidth) +
+        "  " +
+        "Source".padEnd(sourceWidth);
+    const separator = "-".repeat(nameWidth) +
+        "  " +
+        "-".repeat(currentWidth) +
+        "  " +
+        "-".repeat(availableWidth) +
+        "  " +
+        "-".repeat(sourceWidth);
+    console.log(header);
+    console.log(separator);
+    for (const entry of outdated) {
+        console.log(entry.name.padEnd(nameWidth) +
+            "  " +
+            entry.current.padEnd(currentWidth) +
+            "  " +
+            entry.available.padEnd(availableWidth) +
+            "  " +
+            entry.source.padEnd(sourceWidth));
+    }
+    console.log();
+    console.log(`${outdated.length} outdated, ${upToDate} up to date, ${result.total} total`);
+    process.exit(0);
+}

package/dist/commands/profile.d.ts

@@ -0,0 +1,3 @@
+export declare function profileCommand(action: string | undefined, name: string | undefined, skills: string[], opts: {
+    json?: boolean;
+}): Promise<void>;