@sporesec/arcana 2.3.1 → 3.0.0

package/dist/commands/config.js

@@ -20,9 +20,15 @@ export async function configCommand(action, value, opts) {
         const envInstallDir = process.env.ARCANA_INSTALL_DIR;
         const envProvider = process.env.ARCANA_DEFAULT_PROVIDER;
         const rows = [
-            [ui.dim("defaultProvider"), config.defaultProvider + (envProvider ? ` ${ui.warn("(overridden by ARCANA_DEFAULT_PROVIDER)")}` : "")],
-            [ui.dim("installDir"), config.installDir + (envInstallDir ? ` ${ui.warn("(overridden by ARCANA_INSTALL_DIR)")}` : "")],
-            [ui.dim("providers"), config.providers.map(p => p.name).join(", ")],
+            [
+                ui.dim("defaultProvider"),
+                config.defaultProvider + (envProvider ? ` ${ui.warn("(overridden by ARCANA_DEFAULT_PROVIDER)")}` : ""),
+            ],
+            [
+                ui.dim("installDir"),
+                config.installDir + (envInstallDir ? ` ${ui.warn("(overridden by ARCANA_INSTALL_DIR)")}` : ""),
+            ],
+            [ui.dim("providers"), config.providers.map((p) => p.name).join(", ")],
         ];
         table(rows);
         console.log();
@@ -58,7 +64,11 @@ export async function configCommand(action, value, opts) {
             }
             catch (err) {
                 if (opts?.json) {
-                    console.log(JSON.stringify({ action: "reset", success: false, error: err instanceof Error ? err.message : "Failed to remove config" }));
+                    console.log(JSON.stringify({
+                        action: "reset",
+                        success: false,
+                        error: err instanceof Error ? err.message : "Failed to remove config",
+                    }));
                 }
                 else {
                     console.log(ui.error(`  Failed to reset config: ${err instanceof Error ? err.message : "unknown error"}`));
@@ -115,7 +125,7 @@ export async function configCommand(action, value, opts) {
         }
     }
     if (key === "defaultProvider") {
-        const providerNames = config.providers.map(p => p.name);
+        const providerNames = config.providers.map((p) => p.name);
         if (!providerNames.includes(value)) {
             console.log(ui.error(`  Provider '${value}' not configured. Add it first with: arcana providers --add owner/repo`));
             console.log();
@@ -132,4 +142,3 @@ export async function configCommand(action, value, opts) {
         console.log();
     }
 }
-//# sourceMappingURL=config.js.map

package/dist/commands/create.d.ts

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

package/dist/commands/create.js

@@ -65,6 +65,7 @@ export async function createCommand(name) {
                 return "Description is required";
             if (val.length < 10)
                 return "Too short (minimum 10 chars)";
+            return undefined;
         },
     });
     if (p.isCancel(description)) {
@@ -97,4 +98,3 @@ export async function createCommand(name) {
     p.log.info("Edit SKILL.md to add your skill instructions.");
     p.outro(`Next: ${chalk.cyan("arcana validate " + name)}`);
 }
-//# sourceMappingURL=create.js.map

package/dist/commands/diff.d.ts

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

package/dist/commands/diff.js

@@ -0,0 +1,166 @@
+import { existsSync, readFileSync, readdirSync, lstatSync } from "node:fs";
+import { join } from "node:path";
+import { getInstallDir, readSkillMeta } from "../utils/fs.js";
+import { getProvider } from "../registry.js";
+import { loadConfig } from "../utils/config.js";
+import { validateSlug } from "../utils/validate.js";
+function readDirRecursive(dir) {
+    const results = [];
+    const queue = [{ fullDir: dir, relPrefix: "" }];
+    while (queue.length > 0) {
+        const { fullDir, relPrefix } = queue.pop();
+        let entries;
+        try {
+            entries = readdirSync(fullDir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = join(fullDir, entry);
+            try {
+                const stat = lstatSync(fullPath);
+                if (stat.isSymbolicLink())
+                    continue;
+                const relPath = relPrefix ? `${relPrefix}/${entry}` : entry;
+                if (stat.isDirectory()) {
+                    queue.push({ fullDir: fullPath, relPrefix: relPath });
+                }
+                else {
+                    results.push({
+                        path: relPath,
+                        content: readFileSync(fullPath, "utf-8"),
+                    });
+                }
+            }
+            catch {
+                // skip unreadable entries
+            }
+        }
+    }
+    return results;
+}
+function computeLineDiff(localContent, remoteContent) {
+    const localLines = localContent.split("\n");
+    const remoteLines = remoteContent.split("\n");
+    const localSet = new Set(localLines);
+    const remoteSet = new Set(remoteLines);
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const line of remoteLines) {
+        if (!localSet.has(line)) {
+            linesAdded++;
+        }
+    }
+    for (const line of localLines) {
+        if (!remoteSet.has(line)) {
+            linesRemoved++;
+        }
+    }
+    return { linesAdded, linesRemoved };
+}
+export async function diffCommand(skill, opts) {
+    try {
+        validateSlug(skill, "skill name");
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : "Invalid skill name");
+        process.exit(1);
+    }
+    const installDir = getInstallDir();
+    const skillDir = join(installDir, skill);
+    if (!existsSync(skillDir)) {
+        console.error(`Skill "${skill}" is not installed.`);
+        process.exit(1);
+    }
+    const providerName = opts.provider ?? loadConfig().defaultProvider;
+    const provider = getProvider(providerName);
+    let remoteFiles;
+    try {
+        remoteFiles = await provider.fetch(skill);
+    }
+    catch (err) {
+        console.error(`Failed to fetch remote skill "${skill}": ${err instanceof Error ? err.message : "unknown error"}`);
+        process.exit(1);
+    }
+    const localFiles = readDirRecursive(skillDir);
+    const meta = readSkillMeta(skill);
+    const localVersion = meta?.version ?? "0.0.0";
+    let remoteVersion = "0.0.0";
+    try {
+        const remoteInfo = await provider.info(skill);
+        if (remoteInfo) {
+            remoteVersion = remoteInfo.version;
+        }
+    }
+    catch {
+        // keep default
+    }
+    const localMap = new Map();
+    for (const file of localFiles) {
+        localMap.set(file.path, file.content);
+    }
+    const remoteMap = new Map();
+    for (const file of remoteFiles) {
+        remoteMap.set(file.path, file.content);
+    }
+    const added = [];
+    const removed = [];
+    const modified = [];
+    for (const [path] of remoteMap) {
+        if (!localMap.has(path)) {
+            added.push(path);
+        }
+    }
+    for (const [path] of localMap) {
+        if (!remoteMap.has(path)) {
+            removed.push(path);
+        }
+    }
+    for (const [path, remoteContent] of remoteMap) {
+        const localContent = localMap.get(path);
+        if (localContent !== undefined && localContent !== remoteContent) {
+            const { linesAdded, linesRemoved } = computeLineDiff(localContent, remoteContent);
+            modified.push({ path, linesAdded, linesRemoved });
+        }
+    }
+    const result = {
+        skill,
+        localVersion,
+        remoteVersion,
+        added,
+        removed,
+        modified,
+    };
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Console output
+    console.log(`Diff: ${skill}`);
+    console.log(`  Local version:  ${localVersion}`);
+    console.log(`  Remote version: ${remoteVersion}`);
+    console.log();
+    if (added.length === 0 && removed.length === 0 && modified.length === 0) {
+        console.log("  No differences found.");
+        return;
+    }
+    if (added.length > 0) {
+        console.log(`  Added (${added.length}):`);
+        for (const path of added) {
+            console.log(`    + ${path}`);
+        }
+    }
+    if (removed.length > 0) {
+        console.log(`  Removed (${removed.length}):`);
+        for (const path of removed) {
+            console.log(`    - ${path}`);
+        }
+    }
+    if (modified.length > 0) {
+        console.log(`  Modified (${modified.length}):`);
+        for (const entry of modified) {
+            console.log(`    ~ ${entry.path}  (+${entry.linesAdded} / -${entry.linesRemoved})`);
+        }
+    }
+}

package/dist/commands/doctor.d.ts

@@ -3,4 +3,3 @@ export declare function runDoctorChecks(): DoctorCheck[];
 export declare function doctorCommand(opts?: {
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.js

@@ -3,20 +3,30 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { execSync } from "node:child_process";
 import { ui, banner, suggest } from "../utils/ui.js";
-import { getInstallDir, getDirSize, listSymlinks } from "../utils/fs.js";
+import { getInstallDir, getDirSize, listSymlinks, isOrphanedProject } from "../utils/fs.js";
 function checkNodeVersion() {
     const major = parseInt(process.version.slice(1));
     if (major >= 18) {
         return { name: "Node.js", status: "pass", message: `${process.version}` };
     }
-    return { name: "Node.js", status: "fail", message: `${process.version} (need 18+)`, fix: "Install Node.js 18 or later" };
+    return {
+        name: "Node.js",
+        status: "fail",
+        message: `${process.version} (need 18+)`,
+        fix: "Install Node.js 18 or later",
+    };
 }
 function checkInstallDir() {
     const dir = getInstallDir();
     if (!existsSync(dir)) {
-        return { name: "Skills directory", status: "warn", message: "~/.agents/skills/ not found", fix: "Run: arcana install --all" };
+        return {
+            name: "Skills directory",
+            status: "warn",
+            message: "~/.agents/skills/ not found",
+            fix: "Run: arcana install --all",
+        };
     }
-    const skills = readdirSync(dir).filter(d => statSync(join(dir, d)).isDirectory());
+    const skills = readdirSync(dir).filter((d) => statSync(join(dir, d)).isDirectory());
     return { name: "Skills directory", status: "pass", message: `${skills.length} skills installed` };
 }
 function checkBrokenSymlinks() {
@@ -24,9 +34,14 @@ function checkBrokenSymlinks() {
     if (symlinks.length === 0) {
         return { name: "Symlinks", status: "pass", message: "No symlink directory" };
     }
-    const broken = symlinks.filter(s => s.broken).length;
+    const broken = symlinks.filter((s) => s.broken).length;
     if (broken > 0) {
-        return { name: "Symlinks", status: "warn", message: `${broken}/${symlinks.length} broken symlinks`, fix: "Run: arcana clean" };
+        return {
+            name: "Symlinks",
+            status: "warn",
+            message: `${broken}/${symlinks.length} broken symlinks`,
+            fix: "Run: arcana clean",
+        };
     }
     return { name: "Symlinks", status: "pass", message: `${symlinks.length} symlinks ok` };
 }
@@ -35,12 +50,22 @@ function checkGitConfig() {
         const name = execSync("git config user.name", { encoding: "utf-8" }).trim();
         const email = execSync("git config user.email", { encoding: "utf-8" }).trim();
         if (!name || !email) {
-            return { name: "Git config", status: "warn", message: "Missing user.name or user.email", fix: "git config --global user.name \"Your Name\"" };
+            return {
+                name: "Git config",
+                status: "warn",
+                message: "Missing user.name or user.email",
+                fix: 'git config --global user.name "Your Name"',
+            };
         }
         return { name: "Git config", status: "pass", message: `${name} <${email}>` };
     }
     catch {
-        return { name: "Git config", status: "warn", message: "Git not found", fix: "Install Git from https://git-scm.com" };
+        return {
+            name: "Git config",
+            status: "warn",
+            message: "Git not found",
+            fix: "Install Git from https://git-scm.com",
+        };
     }
 }
 function checkArcanaConfig() {
@@ -73,10 +98,16 @@ function checkDiskUsage() {
             }
         }
     }
-    catch { /* skip */ }
+    catch {
+        /* skip */
+    }
     const mb = (totalSize / (1024 * 1024)).toFixed(1);
     if (totalSize > DISK_USAGE_THRESHOLD_MB * 1024 * 1024) {
-        return { name: "Disk usage", status: "warn", message: `${mb} MB across ${dirCount} projects (threshold: ${DISK_USAGE_THRESHOLD_MB} MB). Try: arcana clean` };
+        return {
+            name: "Disk usage",
+            status: "warn",
+            message: `${mb} MB across ${dirCount} projects (threshold: ${DISK_USAGE_THRESHOLD_MB} MB). Try: arcana clean`,
+        };
     }
     return { name: "Disk usage", status: "pass", message: `${mb} MB across ${dirCount} projects` };
 }
@@ -114,14 +145,12 @@ function checkSkillValidity() {
     if (invalid === 0) {
         return { name: "Skill health", status: "pass", message: `${total} skills valid` };
     }
-    // Pick the most useful fix command
     const details = [];
     let fix;
     if (missingMd.length > 0) {
         details.push(`${missingMd.length} missing SKILL.md (${missingMd.join(", ")})`);
-        fix = missingMd.length === 1
-            ? `Run: arcana uninstall ${missingMd[0]}`
-            : `Run: arcana uninstall ${missingMd.join(" ")}`;
+        fix =
+            missingMd.length === 1 ? `Run: arcana uninstall ${missingMd[0]}` : `Run: arcana uninstall ${missingMd.join(" ")}`;
     }
     else {
         fix = "Run: arcana validate --all --fix";
@@ -142,24 +171,117 @@ function checkSkillSizes() {
         return { name: "Skill sizes", status: "pass", message: "No skills to check" };
     }
     const large = [];
+    let totalKB = 0;
     for (const entry of readdirSync(dir)) {
         const skillDir = join(dir, entry);
         if (!statSync(skillDir).isDirectory())
             continue;
         const size = getDirSize(skillDir);
         const kb = size / 1024;
+        totalKB += kb;
         if (kb > 50)
             large.push({ name: entry, kb });
     }
     if (large.length === 0) {
-        return { name: "Skill sizes", status: "pass", message: "All skills under 50 KB" };
+        return {
+            name: "Skill sizes",
+            status: "pass",
+            message: `All skills under 50 KB (total: ${totalKB.toFixed(0)} KB, ~${Math.round((totalKB * 256) / 1000)}K tokens)`,
+        };
     }
     large.sort((a, b) => b.kb - a.kb);
-    const top3 = large.slice(0, 3).map(s => `${s.name} (${s.kb.toFixed(0)} KB)`).join(", ");
+    const top3 = large
+        .slice(0, 3)
+        .map((s) => `${s.name} (${s.kb.toFixed(0)} KB)`)
+        .join(", ");
     return {
         name: "Skill sizes",
         status: "warn",
-        message: `${large.length} skills >50 KB (high token usage). Largest: ${top3}`,
+        message: `${large.length} skills >50 KB (high token usage). Total: ${totalKB.toFixed(0)} KB (~${Math.round((totalKB * 256) / 1000)}K tokens). Largest: ${top3}`,
+    };
+}
+function checkOrphanedProjects() {
+    const projectsDir = join(homedir(), ".claude", "projects");
+    if (!existsSync(projectsDir)) {
+        return { name: "Orphaned projects", status: "pass", message: "No project data" };
+    }
+    const orphans = [];
+    for (const entry of readdirSync(projectsDir)) {
+        const full = join(projectsDir, entry);
+        if (!statSync(full).isDirectory())
+            continue;
+        if (entry === "memory" || entry.startsWith("."))
+            continue;
+        if (isOrphanedProject(entry)) {
+            orphans.push({ name: entry, sizeMB: getDirSize(full) / (1024 * 1024) });
+        }
+    }
+    if (orphans.length === 0) {
+        return { name: "Orphaned projects", status: "pass", message: "All project dirs have matching source" };
+    }
+    const totalMB = orphans.reduce((sum, o) => sum + o.sizeMB, 0).toFixed(1);
+    return {
+        name: "Orphaned projects",
+        status: "warn",
+        message: `${orphans.length} orphaned project dirs (${totalMB} MB). Source code no longer exists.`,
+        fix: "Run: arcana clean",
+    };
+}
+function checkSessionBloat() {
+    const projectsDir = join(homedir(), ".claude", "projects");
+    if (!existsSync(projectsDir)) {
+        return { name: "Session bloat", status: "pass", message: "No session data" };
+    }
+    const bloated = [];
+    for (const project of readdirSync(projectsDir)) {
+        const projDir = join(projectsDir, project);
+        if (!statSync(projDir).isDirectory())
+            continue;
+        for (const file of readdirSync(projDir)) {
+            if (!file.endsWith(".jsonl"))
+                continue;
+            const stat = statSync(join(projDir, file));
+            const mb = stat.size / (1024 * 1024);
+            if (mb > 50) {
+                bloated.push({ project, file, sizeMB: mb });
+            }
+        }
+    }
+    if (bloated.length === 0) {
+        return { name: "Session bloat", status: "pass", message: "No session files >50 MB" };
+    }
+    bloated.sort((a, b) => b.sizeMB - a.sizeMB);
+    const top = bloated[0];
+    const totalMB = bloated.reduce((sum, b) => sum + b.sizeMB, 0).toFixed(0);
+    return {
+        name: "Session bloat",
+        status: "warn",
+        message: `${bloated.length} session files >50 MB (${totalMB} MB total). Largest: ${top.project} (${top.sizeMB.toFixed(0)} MB)`,
+        fix: "Run: arcana clean --aggressive",
+    };
+}
+function checkAuxiliaryBloat() {
+    const claudeDir = join(homedir(), ".claude");
+    const dirs = ["file-history", "debug", "shell-snapshots", "todos", "plans"];
+    let totalMB = 0;
+    const bloated = [];
+    for (const dirName of dirs) {
+        const dir = join(claudeDir, dirName);
+        if (!existsSync(dir))
+            continue;
+        const sizeMB = getDirSize(dir) / (1024 * 1024);
+        totalMB += sizeMB;
+        if (sizeMB > 10)
+            bloated.push(`${dirName} (${sizeMB.toFixed(0)} MB)`);
+    }
+    if (totalMB < 10) {
+        return { name: "Auxiliary data", status: "pass", message: `${totalMB.toFixed(1)} MB across temp directories` };
+    }
+    return {
+        name: "Auxiliary data",
+        status: "warn",
+        message: `${totalMB.toFixed(0)} MB in temp directories${bloated.length > 0 ? `. Bloated: ${bloated.join(", ")}` : ""}`,
+        fix: "Run: arcana clean",
     };
 }
 export function runDoctorChecks() {
@@ -172,6 +294,9 @@ export function runDoctorChecks() {
         checkGitConfig(),
         checkArcanaConfig(),
         checkDiskUsage(),
+        checkOrphanedProjects(),
+        checkSessionBloat(),
+        checkAuxiliaryBloat(),
     ];
 }
 export async function doctorCommand(opts = {}) {
@@ -181,20 +306,25 @@ export async function doctorCommand(opts = {}) {
     }
     const checks = runDoctorChecks();
     if (opts.json) {
-        console.log(JSON.stringify({ checks: checks.map((c) => ({ name: c.name, status: c.status, message: c.message, ...(c.fix ? { fix: c.fix } : {}) })) }, null, 2));
+        console.log(JSON.stringify({
+            checks: checks.map((c) => ({
+                name: c.name,
+                status: c.status,
+                message: c.message,
+                ...(c.fix ? { fix: c.fix } : {}),
+            })),
+        }, null, 2));
         return;
     }
     for (const check of checks) {
-        const icon = check.status === "pass" ? ui.success("[OK]")
-            : check.status === "warn" ? ui.warn("[!!]")
-                : ui.error("[XX]");
+        const icon = check.status === "pass" ? ui.success("[OK]") : check.status === "warn" ? ui.warn("[!!]") : ui.error("[XX]");
         console.log(`  ${icon} ${ui.bold(check.name)}: ${check.message}`);
         if (check.fix) {
             console.log(ui.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;
     console.log();
     if (fails > 0) {
         console.log(ui.error(`  ${fails} issue${fails > 1 ? "s" : ""} found`));
@@ -210,4 +340,3 @@ export async function doctorCommand(opts = {}) {
         suggest("arcana list");
     }
 }
-//# sourceMappingURL=doctor.js.map

package/dist/commands/export-cmd.d.ts

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

package/dist/commands/export-cmd.js

@@ -0,0 +1,66 @@
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getInstallDir, readSkillMeta } from "../utils/fs.js";
+import { readLockfile } from "../utils/integrity.js";
+function getInstalledSkillDirs() {
+    const installDir = getInstallDir();
+    try {
+        return readdirSync(installDir).filter((d) => statSync(join(installDir, d)).isDirectory());
+    }
+    catch {
+        return [];
+    }
+}
+export async function exportCommand(opts) {
+    const dirs = getInstalledSkillDirs();
+    if (dirs.length === 0) {
+        console.log(JSON.stringify({ skills: [], message: "No skills installed" }));
+        return;
+    }
+    if (opts.sbom) {
+        return exportSbom(dirs);
+    }
+    return exportManifest(dirs);
+}
+function exportManifest(dirs) {
+    const skills = [];
+    for (const name of dirs) {
+        const meta = readSkillMeta(name);
+        skills.push({
+            name,
+            version: meta?.version ?? "unknown",
+            source: meta?.source ?? "local",
+            description: meta?.description ?? "",
+        });
+    }
+    const manifest = {
+        exportedAt: new Date().toISOString(),
+        skillCount: skills.length,
+        skills,
+    };
+    console.log(JSON.stringify(manifest, null, 2));
+}
+function exportSbom(dirs) {
+    const lockEntries = readLockfile();
+    const lockMap = new Map(lockEntries.map((e) => [e.skill, e]));
+    const packages = [];
+    for (const name of dirs) {
+        const meta = readSkillMeta(name);
+        const lock = lockMap.get(name);
+        packages.push({
+            name,
+            version: meta?.version ?? lock?.version ?? "unknown",
+            source: meta?.source ?? lock?.source ?? "local",
+            hash: lock?.hash ?? "unknown",
+        });
+    }
+    const sbom = {
+        spdxVersion: "SPDX-2.3",
+        dataLicense: "CC0-1.0",
+        name: "arcana-skills-sbom",
+        documentNamespace: `https://arcana.dev/sbom/${Date.now()}`,
+        createdAt: new Date().toISOString(),
+        packages,
+    };
+    console.log(JSON.stringify(sbom, null, 2));
+}

package/dist/commands/import-cmd.d.ts

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