@sporesec/arcana 2.3.1 → 3.0.0

package/dist/commands/stats.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { ui, banner, table } from "../utils/ui.js";
 import { readHistory } from "../utils/history.js";
+import { getDirSize } from "../utils/fs.js";
 function discoverSessions() {
     const projectsDir = join(homedir(), ".claude", "projects");
     if (!existsSync(projectsDir))
@@ -58,6 +59,44 @@ function formatBytes(bytes) {
         return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
     return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
+function getDiskBreakdown() {
+    const claudeDir = join(homedir(), ".claude");
+    const dirs = [
+        "projects",
+        "file-history",
+        "skills",
+        "debug",
+        "todos",
+        "shell-snapshots",
+        "plans",
+        "cache",
+        "usage-data",
+    ];
+    const breakdown = [];
+    for (const dirName of dirs) {
+        const dir = join(claudeDir, dirName);
+        if (!existsSync(dir))
+            continue;
+        breakdown.push({ name: dirName, sizeBytes: getDirSize(dir) });
+    }
+    breakdown.sort((a, b) => b.sizeBytes - a.sizeBytes);
+    return breakdown;
+}
+function getProjectBreakdown() {
+    const projectsDir = join(homedir(), ".claude", "projects");
+    if (!existsSync(projectsDir))
+        return [];
+    const projects = [];
+    for (const entry of readdirSync(projectsDir)) {
+        const full = join(projectsDir, entry);
+        if (!statSync(full).isDirectory())
+            continue;
+        const jsonlCount = readdirSync(full).filter((f) => f.endsWith(".jsonl")).length;
+        projects.push({ name: entry, sizeBytes: getDirSize(full), sessionCount: jsonlCount });
+    }
+    projects.sort((a, b) => b.sizeBytes - a.sizeBytes);
+    return projects;
+}
 export async function statsCommand(opts) {
     if (!opts.json)
         banner();
@@ -77,9 +116,7 @@ export async function statsCommand(opts) {
     const avgLines = Math.round(totalLines / sessions.length);
     // Rough token estimate: ~4 chars per token for LLM tokenizers
     const estimatedTokens = Math.round(totalSize / 4);
-    // Find unique projects
     const projects = new Set(sessions.map((s) => s.project));
-    // Find most recent and oldest sessions
     const sorted = [...sessions].sort((a, b) => b.modified.getTime() - a.modified.getTime());
     const newest = sorted[0];
     const oldest = sorted[sorted.length - 1];
@@ -88,9 +125,16 @@ export async function statsCommand(opts) {
     for (const s of sessions) {
         projectCounts.set(s.project, (projectCounts.get(s.project) ?? 0) + 1);
     }
-    const topProjects = [...projectCounts.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 5);
+    const topProjects = [...projectCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+    // Disk breakdown
+    const diskBreakdown = getDiskBreakdown();
+    const projectBreakdown = getProjectBreakdown();
+    const totalDisk = diskBreakdown.reduce((sum, d) => sum + d.sizeBytes, 0);
+    // Calculate reclaimable space (auxiliary dirs)
+    const reclaimableDirs = ["file-history", "debug", "shell-snapshots", "todos", "plans"];
+    const reclaimable = diskBreakdown
+        .filter((d) => reclaimableDirs.includes(d.name))
+        .reduce((sum, d) => sum + d.sizeBytes, 0);
     if (opts.json) {
         const data = {
             totalSessions: sessions.length,
@@ -98,10 +142,12 @@ export async function statsCommand(opts) {
             totalSizeBytes: totalSize,
             estimatedTokens,
             avgLinesPerSession: avgLines,
-            topProjects: topProjects.map(([name, count]) => ({
-                name,
-                sessions: count,
-            })),
+            topProjects: topProjects.map(([name, count]) => ({ name, sessions: count })),
+            diskBreakdown: diskBreakdown.map((d) => ({ name: d.name, sizeBytes: d.sizeBytes })),
+            projectBreakdown: projectBreakdown
+                .slice(0, 10)
+                .map((p) => ({ name: p.name, sizeBytes: p.sizeBytes, sessions: p.sessionCount })),
+            reclaimableBytes: reclaimable,
         };
         console.log(JSON.stringify(data, null, 2));
         return;
@@ -110,13 +156,34 @@ export async function statsCommand(opts) {
     const rows = [
         [ui.dim("Sessions"), String(sessions.length)],
         [ui.dim("Projects"), String(projects.size)],
-        [ui.dim("Total data"), formatBytes(totalSize)],
+        [ui.dim("Total session data"), formatBytes(totalSize)],
         [ui.dim("Est. tokens"), `~${(estimatedTokens / 1_000_000).toFixed(1)}M (rough)`],
         [ui.dim("Avg lines/session"), String(avgLines)],
         [ui.dim("Newest session"), newest.modified.toLocaleDateString()],
         [ui.dim("Oldest session"), oldest.modified.toLocaleDateString()],
     ];
     table(rows);
+    // Disk breakdown
+    console.log();
+    console.log(ui.bold("  Disk Breakdown\n"));
+    const diskRows = diskBreakdown
+        .filter((d) => d.sizeBytes > 0)
+        .map((d) => [ui.dim(`~/.claude/${d.name}/`), formatBytes(d.sizeBytes)]);
+    diskRows.push([ui.bold("Total"), ui.bold(formatBytes(totalDisk))]);
+    table(diskRows);
+    // Per-project breakdown (top 5)
+    if (projectBreakdown.length > 0) {
+        console.log();
+        console.log(ui.bold("  Projects by Size\n"));
+        const projRows = projectBreakdown
+            .slice(0, 5)
+            .map((p) => [
+            ui.dim(p.name.length > 45 ? p.name.slice(0, 42) + "..." : p.name),
+            formatBytes(p.sizeBytes),
+            `${p.sessionCount} sessions`,
+        ]);
+        table(projRows);
+    }
     if (topProjects.length > 0) {
         console.log();
         console.log(ui.bold("  Most Active Projects\n"));
@@ -126,18 +193,18 @@ export async function statsCommand(opts) {
         ]);
         table(projRows);
     }
+    // Cleanup suggestion
+    if (reclaimable > 1024 * 1024) {
+        console.log();
+        console.log(ui.warn(`  ${formatBytes(reclaimable)} reclaimable in temp directories. Run: arcana clean`));
+    }
     const history = readHistory();
     if (history.length > 0) {
         console.log();
         console.log(ui.bold("  Recent Arcana Activity\n"));
         const recent = history.slice(-5).reverse();
-        const histRows = recent.map(e => [
-            ui.dim(new Date(e.timestamp).toLocaleDateString()),
-            e.action,
-            e.target ?? "",
-        ]);
+        const histRows = recent.map((e) => [ui.dim(new Date(e.timestamp).toLocaleDateString()), e.action, e.target ?? ""]);
         table(histRows);
     }
     console.log();
 }
-//# sourceMappingURL=stats.js.map

package/dist/commands/team.d.ts

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

package/dist/commands/team.js

@@ -0,0 +1,291 @@
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteSync } from "../utils/atomic.js";
+import { isSkillInstalled, readSkillMeta } from "../utils/fs.js";
+import { validateSlug } from "../utils/validate.js";
+const TEAM_DIR = ".arcana";
+const TEAM_FILE = "team.json";
+function getTeamConfigPath() {
+    return join(process.cwd(), TEAM_DIR, TEAM_FILE);
+}
+function readTeamConfig() {
+    const configPath = getTeamConfigPath();
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeTeamConfig(config) {
+    const dir = join(process.cwd(), TEAM_DIR);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    atomicWriteSync(getTeamConfigPath(), JSON.stringify(config, null, 2) + "\n", 0o644);
+}
+function output(json, message) {
+    if (!json) {
+        console.log(message);
+    }
+}
+export async function teamCommand(action, skill, opts) {
+    if (action === "init") {
+        return teamInit(opts);
+    }
+    if (action === "sync") {
+        return teamSync(opts);
+    }
+    if (action === "add") {
+        if (!skill) {
+            if (opts.json) {
+                console.log(JSON.stringify({ error: "Skill name required for add" }));
+            }
+            else {
+                console.error("Error: Skill name required. Usage: arcana team add <skill>");
+            }
+            process.exit(1);
+        }
+        return teamAdd(skill, opts);
+    }
+    if (action === "remove") {
+        if (!skill) {
+            if (opts.json) {
+                console.log(JSON.stringify({ error: "Skill name required for remove" }));
+            }
+            else {
+                console.error("Error: Skill name required. Usage: arcana team remove <skill>");
+            }
+            process.exit(1);
+        }
+        return teamRemove(skill, opts);
+    }
+    if (action === undefined) {
+        return teamList(opts);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ error: `Unknown action: ${action}` }));
+    }
+    else {
+        console.error(`Error: Unknown action "${action}". Valid actions: init, sync, add, remove`);
+    }
+    process.exit(1);
+}
+function teamInit(opts) {
+    const configPath = getTeamConfigPath();
+    if (existsSync(configPath)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "Team config already exists", path: configPath }));
+        }
+        else {
+            console.error(`Error: ${configPath} already exists.`);
+        }
+        process.exit(1);
+    }
+    const config = {
+        skills: [],
+        updatedAt: new Date().toISOString(),
+    };
+    writeTeamConfig(config);
+    if (opts.json) {
+        console.log(JSON.stringify({ created: configPath }));
+    }
+    else {
+        console.log(`Created ${configPath}`);
+        console.log("Add skills with: arcana team add <skill-name>");
+    }
+}
+async function teamSync(opts) {
+    const config = readTeamConfig();
+    if (!config) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "No team config found. Run: arcana team init" }));
+        }
+        else {
+            console.error("Error: No team config found. Run: arcana team init");
+        }
+        process.exit(1);
+    }
+    if (config.skills.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ installed: [], skipped: [], message: "No skills in team config" }));
+        }
+        else {
+            console.log("No skills listed in team config.");
+        }
+        return;
+    }
+    const { installSkill } = await import("../utils/fs.js");
+    const installed = [];
+    const skipped = [];
+    const failed = [];
+    for (const entry of config.skills) {
+        if (isSkillInstalled(entry.name)) {
+            skipped.push(entry.name);
+            continue;
+        }
+        try {
+            validateSlug(entry.name, "skill name");
+        }
+        catch (_err) {
+            output(opts.json, `Invalid skill name: ${entry.name}`);
+            failed.push(entry.name);
+            continue;
+        }
+        // installSkill requires files, but for sync we re-fetch from provider
+        // Lazy import the registry to avoid circular deps at module load
+        try {
+            const { getProvider } = await import("../registry.js");
+            const { loadConfig } = await import("../utils/config.js");
+            const { updateLockEntry } = await import("../utils/integrity.js");
+            const { writeSkillMeta } = await import("../utils/fs.js");
+            const providerName = entry.source ?? loadConfig().defaultProvider;
+            const provider = getProvider(providerName);
+            const files = await provider.fetch(entry.name);
+            installSkill(entry.name, files);
+            const remote = await provider.info(entry.name);
+            const version = remote?.version ?? entry.version ?? "0.0.0";
+            writeSkillMeta(entry.name, {
+                version,
+                installedAt: new Date().toISOString(),
+                source: provider.name,
+                description: remote?.description,
+                fileCount: files.length,
+                sizeBytes: files.reduce((s, f) => s + f.content.length, 0),
+            });
+            updateLockEntry(entry.name, version, provider.name, files);
+            installed.push(entry.name);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "unknown error";
+            output(opts.json, `Failed to install ${entry.name}: ${msg}`);
+            failed.push(entry.name);
+        }
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ installed, skipped, failed }));
+    }
+    else {
+        console.log(`Sync complete: ${installed.length} installed, ${skipped.length} skipped, ${failed.length} failed`);
+    }
+    if (failed.length > 0)
+        process.exit(1);
+}
+function teamAdd(skill, opts) {
+    try {
+        validateSlug(skill, "skill name");
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: err instanceof Error ? err.message : "Invalid skill name" }));
+        }
+        else {
+            console.error(err instanceof Error ? err.message : "Invalid skill name");
+        }
+        process.exit(1);
+    }
+    const config = readTeamConfig();
+    if (!config) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "No team config found. Run: arcana team init" }));
+        }
+        else {
+            console.error("Error: No team config found. Run: arcana team init");
+        }
+        process.exit(1);
+    }
+    const exists = config.skills.find((s) => s.name === skill);
+    if (exists) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: `${skill} is already in team config` }));
+        }
+        else {
+            console.error(`Error: ${skill} is already in team config.`);
+        }
+        process.exit(1);
+    }
+    const entry = { name: skill };
+    // If skill is installed locally, read meta for version/source
+    const meta = readSkillMeta(skill);
+    if (meta) {
+        if (meta.version)
+            entry.version = meta.version;
+        if (meta.source)
+            entry.source = meta.source;
+    }
+    config.skills.push(entry);
+    config.updatedAt = new Date().toISOString();
+    writeTeamConfig(config);
+    if (opts.json) {
+        console.log(JSON.stringify({ added: entry }));
+    }
+    else {
+        console.log(`Added ${skill} to team config.`);
+    }
+}
+function teamRemove(skill, opts) {
+    const config = readTeamConfig();
+    if (!config) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "No team config found. Run: arcana team init" }));
+        }
+        else {
+            console.error("Error: No team config found. Run: arcana team init");
+        }
+        process.exit(1);
+    }
+    const idx = config.skills.findIndex((s) => s.name === skill);
+    if (idx < 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: `${skill} is not in team config` }));
+        }
+        else {
+            console.error(`Error: ${skill} is not in team config.`);
+        }
+        process.exit(1);
+    }
+    config.skills.splice(idx, 1);
+    config.updatedAt = new Date().toISOString();
+    writeTeamConfig(config);
+    if (opts.json) {
+        console.log(JSON.stringify({ removed: skill }));
+    }
+    else {
+        console.log(`Removed ${skill} from team config.`);
+    }
+}
+function teamList(opts) {
+    const config = readTeamConfig();
+    if (!config) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "No team config found. Run: arcana team init" }));
+        }
+        else {
+            console.error("Error: No team config found. Run: arcana team init");
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ skills: config.skills, updatedAt: config.updatedAt }));
+        return;
+    }
+    if (config.skills.length === 0) {
+        console.log("No skills in team config. Add one with: arcana team add <skill>");
+        return;
+    }
+    console.log(`Team skills (${config.skills.length}):`);
+    for (const entry of config.skills) {
+        const parts = [entry.name];
+        if (entry.version)
+            parts.push(`v${entry.version}`);
+        if (entry.source)
+            parts.push(`(${entry.source})`);
+        const installed = isSkillInstalled(entry.name);
+        if (installed)
+            parts.push("[installed]");
+        console.log(`  ${parts.join("  ")}`);
+    }
+}

package/dist/commands/uninstall.d.ts

@@ -3,4 +3,3 @@ export declare function uninstallCommand(skillNames: string[], opts?: {
     json?: boolean;
 }): Promise<void>;
 export declare function removeSymlinksFor(skillName: string): number;
-//# sourceMappingURL=uninstall.d.ts.map

package/dist/commands/uninstall.js

@@ -125,7 +125,12 @@ function uninstallJson(skillNames) {
             validateSlug(skillName, "skill name");
         }
         catch (err) {
-            results.push({ name: skillName, success: false, error: err instanceof Error ? err.message : "Invalid name", symlinksRemoved: 0 });
+            results.push({
+                name: skillName,
+                success: false,
+                error: err instanceof Error ? err.message : "Invalid name",
+                symlinksRemoved: 0,
+            });
             continue;
         }
         const skillDir = getSkillDir(skillName);
@@ -139,7 +144,13 @@ function uninstallJson(skillNames) {
             rmSync(skillDir, { recursive: true, force: true });
         }
         catch (err) {
-            results.push({ name: skillName, success: false, version: meta?.version, error: err instanceof Error ? err.message : "Failed to remove", symlinksRemoved: 0 });
+            results.push({
+                name: skillName,
+                success: false,
+                version: meta?.version,
+                error: err instanceof Error ? err.message : "Failed to remove",
+                symlinksRemoved: 0,
+            });
             continue;
         }
         const symlinksRemoved = removeSymlinksFor(skillName);
@@ -147,7 +158,11 @@ function uninstallJson(skillNames) {
     }
     if (results.length === 1) {
         const r = results[0];
-        const output = { uninstalled: r.name, success: r.success, symlinksRemoved: r.symlinksRemoved };
+        const output = {
+            uninstalled: r.name,
+            success: r.success,
+            symlinksRemoved: r.symlinksRemoved,
+        };
         if (r.version)
             output.version = r.version;
         if (r.error)
@@ -160,4 +175,3 @@ function uninstallJson(skillNames) {
     if (results.some((r) => !r.success))
         process.exit(1);
 }
-//# sourceMappingURL=uninstall.js.map

package/dist/commands/update.d.ts

@@ -4,4 +4,3 @@ export declare function updateCommand(skills: string[], opts: {
     dryRun?: boolean;
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=update.d.ts.map