@sporesec/arcana 2.3.1 → 3.0.0

package/dist/cli.d.ts

@@ -1,3 +1,2 @@
 import { Command } from "commander";
 export declare function createCli(): Command;
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -5,10 +5,7 @@ const require = createRequire(import.meta.url);
 const pkg = require("../package.json");
 export function createCli() {
     const program = new Command();
-    program
-        .name("arcana")
-        .description("Universal AI development CLI")
-        .version(pkg.version);
+    program.name("arcana").description("Universal AI development CLI").version(pkg.version);
     // Store default help formatter before overriding
     const defaultFormatHelp = program.createHelp().formatHelp.bind(program.createHelp());
     program.configureHelp({
@@ -36,8 +33,8 @@ export function createCli() {
         if (cmd) {
             console.error();
             console.error(ui.error("  Error: ") + `unknown command '${cmd}'`);
-            const commands = ["list", "install", "info", "search", "providers", "create", "validate", "update", "uninstall", "init", "doctor", "clean", "stats", "config", "audit", "scan"];
-            const match = commands.find(c => c.startsWith(cmd.slice(0, 3)));
+            const { findClosestCommand } = await import("./command-registry.js");
+            const match = findClosestCommand(cmd);
             if (match) {
                 console.error(ui.dim(`  Did you mean '${match}'?`));
             }
@@ -55,7 +52,7 @@ export function createCli() {
             showWelcome(pkg.version);
             markInitialized();
         }
-        const { showInteractiveMenu } = await import("./interactive.js");
+        const { showInteractiveMenu } = await import("./interactive/index.js");
         await showInteractiveMenu(pkg.version);
     });
     program
@@ -79,6 +76,7 @@ export function createCli() {
         .option("-f, --force", "Reinstall even if already installed")
         .option("--dry-run", "Show what would be installed without installing")
         .option("-j, --json", "Output as JSON")
+        .option("--no-check", "Skip conflict detection")
         .addHelpText("after", "\nExamples:\n  arcana install code-reviewer\n  arcana install skill1 skill2 skill3\n  arcana install --all --force")
         .action(async (skills, opts) => {
         const { installCommand } = await import("./commands/install.js");
@@ -98,8 +96,10 @@ export function createCli() {
         .description("Search for skills across providers")
         .option("-p, --provider <name>", "Limit search to provider")
         .option("--no-cache", "Bypass skill cache")
+        .option("-t, --tag <tag>", "Filter by tech stack tag")
+        .option("-s, --smart", "Context-aware ranking (uses project detection)")
         .option("-j, --json", "Output as JSON")
-        .addHelpText("after", "\nExamples:\n  arcana search testing\n  arcana search \"code review\"")
+        .addHelpText("after", '\nExamples:\n  arcana search testing\n  arcana search "code review"\n  arcana search react --tag typescript\n  arcana search api --smart')
         .action(async (query, opts) => {
         const { searchCommand } = await import("./commands/search.js");
         return searchCommand(query, opts);
@@ -171,13 +171,26 @@ export function createCli() {
     });
     program
         .command("clean")
-        .description("Remove orphaned data and temp files")
+        .description("Remove orphaned data, old session logs, and temp files")
         .option("-n, --dry-run", "Show what would be removed without deleting")
+        .option("--aggressive", "Delete all session logs regardless of age")
+        .option("--keep-days <days>", "Keep main session logs newer than N days (default: 30)", parseInt)
         .option("--json", "Output as JSON")
         .action(async (opts) => {
         const { cleanCommand } = await import("./commands/clean.js");
         return cleanCommand(opts);
     });
+    program
+        .command("compact")
+        .description("Remove agent logs while preserving main session history")
+        .option("-n, --dry-run", "Show what would be removed without deleting")
+        .option("--prune", "Also prune oversized main sessions (>14d old AND >10 MB)")
+        .option("--prune-days <days>", "Override prune age threshold (default: 14)", parseInt)
+        .option("-j, --json", "Output as JSON")
+        .action(async (opts) => {
+        const { compactCommand } = await import("./commands/compact.js");
+        return compactCommand(opts);
+    });
     program
         .command("stats")
         .description("Show session analytics and token usage")
@@ -214,6 +227,123 @@ export function createCli() {
         const { scanCommand } = await import("./commands/scan.js");
         return scanCommand(skill, opts);
     });
+    program
+        .command("optimize")
+        .description("Analyze Claude Code setup and suggest token/performance improvements")
+        .option("-j, --json", "Output as JSON")
+        .action(async (opts) => {
+        const { optimizeCommand } = await import("./commands/optimize.js");
+        return optimizeCommand(opts);
+    });
+    // === Security ===
+    program
+        .command("verify [skill]")
+        .description("Verify installed skill integrity against lockfile")
+        .option("-a, --all", "Verify all installed skills")
+        .option("-j, --json", "Output as JSON")
+        .addHelpText("after", "\nExamples:\n  arcana verify code-reviewer\n  arcana verify --all\n  arcana verify --all --json")
+        .action(async (skill, opts) => {
+        const { verifyCommand } = await import("./commands/verify.js");
+        return verifyCommand(skill, opts);
+    });
+    program
+        .command("lock")
+        .description("Generate or validate lockfile from installed skills")
+        .option("--ci", "Validate lockfile matches installed skills (CI mode)")
+        .option("-j, --json", "Output as JSON")
+        .addHelpText("after", "\nExamples:\n  arcana lock\n  arcana lock --ci\n  arcana lock --json")
+        .action(async (opts) => {
+        const { lockCommand } = await import("./commands/lock.js");
+        return lockCommand(opts);
+    });
+    // === Performance & Inspection ===
+    program
+        .command("benchmark [skill]")
+        .description("Measure token cost of installed skills")
+        .option("-a, --all", "Benchmark all installed skills")
+        .option("-j, --json", "Output as JSON")
+        .addHelpText("after", "\nExamples:\n  arcana benchmark code-reviewer\n  arcana benchmark --all")
+        .action(async (skill, opts) => {
+        const { benchmarkCommand } = await import("./commands/benchmark.js");
+        return benchmarkCommand(skill, opts);
+    });
+    program
+        .command("diff <skill>")
+        .description("Show changes between installed and remote skill version")
+        .option("-p, --provider <name>", "Provider to compare against")
+        .option("-j, --json", "Output as JSON")
+        .addHelpText("after", "\nExamples:\n  arcana diff code-reviewer\n  arcana diff code-reviewer --json")
+        .action(async (skill, opts) => {
+        const { diffCommand } = await import("./commands/diff.js");
+        return diffCommand(skill, opts);
+    });
+    program
+        .command("outdated")
+        .description("List skills with newer versions available")
+        .option("-p, --provider <name>", "Check against specific provider")
+        .option("-j, --json", "Output as JSON")
+        .action(async (opts) => {
+        const { outdatedCommand } = await import("./commands/outdated.js");
+        return outdatedCommand(opts);
+    });
+    // === Workflow & Team ===
+    program
+        .command("profile [action] [name] [skills...]")
+        .description("Manage skill profiles (named sets of skills)")
+        .option("-j, --json", "Output as JSON")
+        .addHelpText("after", "\nActions:\n  list          List all profiles (default)\n  create <name> Create a profile\n  delete <name> Delete a profile\n  show <name>   Show skills in a profile\n  apply <name>  Install all skills from a profile\n\nExamples:\n  arcana profile create security scan verify audit\n  arcana profile apply security")
+        .action(async (action, name, skills, opts) => {
+        const { profileCommand } = await import("./commands/profile.js");
+        return profileCommand(action, name, skills, opts);
+    });
+    program
+        .command("team [action] [skill]")
+        .description("Manage shared team skill configuration")
+        .option("-j, --json", "Output as JSON")
+        .addHelpText("after", "\nActions:\n  init          Create .arcana/team.json\n  sync          Install skills from team config\n  add <skill>   Add a skill to team config\n  remove <skill> Remove a skill from team config\n\nExamples:\n  arcana team init\n  arcana team add code-reviewer\n  arcana team sync")
+        .action(async (action, skill, opts) => {
+        const { teamCommand } = await import("./commands/team.js");
+        return teamCommand(action, skill, opts);
+    });
+    program
+        .command("export")
+        .description("Export installed skills as a manifest")
+        .option("--sbom", "Export as SPDX-lite software bill of materials")
+        .option("-j, --json", "Output as JSON (default)")
+        .action(async (opts) => {
+        const { exportCommand } = await import("./commands/export-cmd.js");
+        return exportCommand(opts);
+    });
+    program
+        .command("import <file>")
+        .description("Import and install skills from a manifest file")
+        .option("-f, --force", "Reinstall even if already installed")
+        .option("-j, --json", "Output as JSON")
+        .addHelpText("after", "\nExamples:\n  arcana import manifest.json\n  arcana import manifest.json --force")
+        .action(async (file, opts) => {
+        const { importCommand } = await import("./commands/import-cmd.js");
+        return importCommand(file, opts);
+    });
+    program
+        .command("completions <shell>")
+        .description("Generate shell completion scripts")
+        .option("-j, --json", "Output as JSON")
+        .addHelpText("after", "\nSupported shells: bash, zsh, fish\n\nExamples:\n  arcana completions bash >> ~/.bashrc\n  arcana completions zsh >> ~/.zshrc\n  arcana completions fish > ~/.config/fish/completions/arcana.fish")
+        .action(async (shell, opts) => {
+        const { completionsCommand } = await import("./commands/completions.js");
+        return completionsCommand(shell, opts);
+    });
+    // ── Smart Recommendations ──────────────────────────────────────
+    program
+        .command("recommend")
+        .description("Get smart skill recommendations for current project")
+        .option("-j, --json", "Output as JSON")
+        .option("-l, --limit <n>", "Max results per category", parseInt)
+        .option("-p, --provider <name>", "Limit to provider")
+        .addHelpText("after", "\nExamples:\n  arcana recommend\n  arcana recommend --json\n  arcana recommend --limit 5")
+        .action(async (opts) => {
+        const { recommendCommand } = await import("./commands/recommend.js");
+        return recommendCommand(opts);
+    });
     return program;
 }
-//# sourceMappingURL=cli.js.map

package/dist/command-registry.d.ts

@@ -0,0 +1,10 @@
+export interface CommandEntry {
+    name: string;
+    usage: string;
+    description: string;
+    group: string;
+}
+export declare function getCommandNames(): string[];
+export declare function getGroupedCommands(): Record<string, CommandEntry[]>;
+export declare function findClosestCommand(input: string): string | undefined;
+export declare function getCliReference(): string;

package/dist/command-registry.js

@@ -0,0 +1,65 @@
+const COMMANDS = [
+    // Getting Started
+    { name: "init", usage: "init", description: "Initialize arcana in current project", group: "GETTING STARTED" },
+    { name: "doctor", usage: "doctor", description: "Check environment and diagnose issues", group: "GETTING STARTED" },
+    // Skills
+    { name: "list", usage: "list", description: "List available skills", group: "SKILLS" },
+    { name: "search", usage: "search <query>", description: "Search across providers", group: "SKILLS" },
+    { name: "info", usage: "info <skill>", description: "Show skill details", group: "SKILLS" },
+    { name: "install", usage: "install [skills...]", description: "Install one or more skills", group: "SKILLS" },
+    { name: "update", usage: "update [skills...]", description: "Update installed skills", group: "SKILLS" },
+    { name: "uninstall", usage: "uninstall [skills...]", description: "Remove one or more skills", group: "SKILLS" },
+    { name: "recommend", usage: "recommend", description: "Smart skill recommendations", group: "SKILLS" },
+    // Development
+    { name: "create", usage: "create <name>", description: "Create a new skill from template", group: "DEVELOPMENT" },
+    { name: "validate", usage: "validate [skill]", description: "Validate skill structure", group: "DEVELOPMENT" },
+    { name: "audit", usage: "audit [skill]", description: "Audit skill quality", group: "DEVELOPMENT" },
+    // Security
+    { name: "scan", usage: "scan [skill]", description: "Scan skills for security threats", group: "SECURITY" },
+    { name: "verify", usage: "verify [skill]", description: "Verify skill integrity", group: "SECURITY" },
+    { name: "lock", usage: "lock", description: "Generate or validate lockfile", group: "SECURITY" },
+    // Inspection
+    { name: "benchmark", usage: "benchmark [skill]", description: "Measure token cost", group: "INSPECTION" },
+    { name: "diff", usage: "diff <skill>", description: "Show installed vs remote changes", group: "INSPECTION" },
+    { name: "outdated", usage: "outdated", description: "List skills with newer versions", group: "INSPECTION" },
+    // Configuration
+    {
+        name: "config",
+        usage: "config [key] [val]",
+        description: "View or modify configuration",
+        group: "CONFIGURATION",
+    },
+    { name: "providers", usage: "providers", description: "Manage skill providers", group: "CONFIGURATION" },
+    { name: "clean", usage: "clean", description: "Remove orphaned data", group: "CONFIGURATION" },
+    { name: "compact", usage: "compact", description: "Remove agent logs", group: "CONFIGURATION" },
+    { name: "stats", usage: "stats", description: "Show session analytics", group: "CONFIGURATION" },
+    {
+        name: "optimize",
+        usage: "optimize",
+        description: "Suggest token/performance improvements",
+        group: "CONFIGURATION",
+    },
+    // Team & Workflow
+    { name: "profile", usage: "profile [action]", description: "Manage skill profiles", group: "WORKFLOW" },
+    { name: "team", usage: "team [action]", description: "Shared team skill config", group: "WORKFLOW" },
+    { name: "export", usage: "export", description: "Export installed skills manifest", group: "WORKFLOW" },
+    { name: "import", usage: "import <file>", description: "Import skills from manifest", group: "WORKFLOW" },
+    { name: "completions", usage: "completions <shell>", description: "Generate shell completions", group: "WORKFLOW" },
+];
+export function getCommandNames() {
+    return COMMANDS.map((c) => c.name);
+}
+export function getGroupedCommands() {
+    const groups = {};
+    for (const cmd of COMMANDS) {
+        (groups[cmd.group] ??= []).push(cmd);
+    }
+    return groups;
+}
+export function findClosestCommand(input) {
+    const prefix = input.slice(0, 3).toLowerCase();
+    return COMMANDS.find((c) => c.name.startsWith(prefix))?.name;
+}
+export function getCliReference() {
+    return COMMANDS.map((c) => `arcana ${c.usage}`).join("\n");
+}

package/dist/commands/audit.d.ts

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

package/dist/commands/audit.js

@@ -53,7 +53,11 @@ export function auditSkill(skillDir, skillName) {
     // 6. Not a capabilities list (detects pattern of many "- " lines with no code between them)
     const bulletLines = (body.match(/^- /gm) || []).length;
     const isCapabilityList = bulletLines > 20 && codeBlockCount < 3;
-    checks.push({ name: "Not a capabilities list", passed: !isCapabilityList, detail: isCapabilityList ? `${bulletLines} bullets, ${Math.floor(codeBlockCount)} code blocks` : undefined });
+    checks.push({
+        name: "Not a capabilities list",
+        passed: !isCapabilityList,
+        detail: isCapabilityList ? `${bulletLines} bullets, ${Math.floor(codeBlockCount)} code blocks` : undefined,
+    });
     if (!isCapabilityList)
         score += 15;
     // 7. Reasonable length (50-500 lines)
@@ -65,7 +69,11 @@ export function auditSkill(skillDir, skillName) {
     const hasScripts = existsSync(join(skillDir, "scripts"));
     const hasRefs = existsSync(join(skillDir, "references")) || existsSync(join(skillDir, "rules"));
     const hasExtras = hasScripts || hasRefs;
-    checks.push({ name: "Has scripts/ or references/", passed: hasExtras, detail: hasExtras ? [hasScripts && "scripts", hasRefs && "references"].filter(Boolean).join(", ") : "none" });
+    checks.push({
+        name: "Has scripts/ or references/",
+        passed: hasExtras,
+        detail: hasExtras ? [hasScripts && "scripts", hasRefs && "references"].filter(Boolean).join(", ") : "none",
+    });
     if (hasExtras)
         score += 10;
     // Rating
@@ -129,9 +137,12 @@ export async function auditCommand(skill, opts) {
     const counts = { PERFECT: 0, STRONG: 0, ADEQUATE: 0, WEAK: 0 };
     for (const r of results) {
         counts[r.rating]++;
-        const ratingColor = r.rating === "PERFECT" ? ui.success
-            : r.rating === "STRONG" ? ui.cyan
-                : r.rating === "ADEQUATE" ? ui.warn
+        const ratingColor = r.rating === "PERFECT"
+            ? ui.success
+            : r.rating === "STRONG"
+                ? ui.cyan
+                : r.rating === "ADEQUATE"
+                    ? ui.warn
                     : ui.error;
         console.log(`  ${ratingColor(`[${r.rating}]`)} ${ui.bold(r.skill)} ${ui.dim(`(${r.score}/100)`)}`);
         for (const check of r.checks) {
@@ -154,4 +165,3 @@ export async function auditCommand(skill, opts) {
     console.log(`  ${parts.join(ui.dim(" | "))}`);
     console.log();
 }
-//# sourceMappingURL=audit.js.map

package/dist/commands/benchmark.d.ts

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

package/dist/commands/benchmark.js

@@ -0,0 +1,178 @@
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getInstallDir, readSkillMeta, getDirSize } from "../utils/fs.js";
+import { CONTEXT_WINDOW_TOKENS } from "../constants.js";
+function collectFiles(dir, prefix) {
+    const entries = [];
+    for (const entry of readdirSync(dir)) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            entries.push(...collectFiles(fullPath, prefix ? `${prefix}/${entry}` : entry));
+        }
+        else {
+            entries.push({ path: prefix ? `${prefix}/${entry}` : entry, sizeBytes: stat.size });
+        }
+    }
+    return entries;
+}
+function benchmarkSkill(skillName) {
+    const installDir = getInstallDir();
+    const skillDir = join(installDir, skillName);
+    try {
+        statSync(skillDir);
+    }
+    catch {
+        return null;
+    }
+    const files = collectFiles(skillDir, "");
+    const totalBytes = getDirSize(skillDir);
+    const estimatedTokens = Math.round(totalBytes / 4);
+    const contextPercent = (estimatedTokens / CONTEXT_WINDOW_TOKENS) * 100;
+    return {
+        name: skillName,
+        fileCount: files.length,
+        totalBytes,
+        estimatedTokens,
+        contextPercent,
+        files,
+    };
+}
+function formatKB(bytes) {
+    return (bytes / 1024).toFixed(1) + " KB";
+}
+function formatTokens(tokens) {
+    if (tokens >= 1_000_000)
+        return (tokens / 1_000_000).toFixed(1) + "M";
+    if (tokens >= 1_000)
+        return (tokens / 1_000).toFixed(1) + "k";
+    return String(tokens);
+}
+export async function benchmarkCommand(skill, opts) {
+    const installDir = getInstallDir();
+    if (skill) {
+        return benchmarkSingle(skill, opts.json);
+    }
+    if (opts.all) {
+        return benchmarkAll(installDir, opts.json);
+    }
+    console.error("Specify a skill name or use --all to benchmark all installed skills.");
+    console.error("Usage: arcana benchmark <skill-name>");
+    console.error("       arcana benchmark --all");
+    process.exit(1);
+}
+function benchmarkSingle(skillName, json) {
+    const result = benchmarkSkill(skillName);
+    if (!result) {
+        if (json) {
+            console.log(JSON.stringify({ error: `Skill "${skillName}" not found` }));
+        }
+        else {
+            console.error(`Skill "${skillName}" is not installed.`);
+        }
+        process.exit(1);
+    }
+    const meta = readSkillMeta(skillName);
+    if (json) {
+        console.log(JSON.stringify({
+            name: result.name,
+            version: meta?.version ?? "unknown",
+            fileCount: result.fileCount,
+            totalBytes: result.totalBytes,
+            estimatedTokens: result.estimatedTokens,
+            contextPercent: Math.round(result.contextPercent * 100) / 100,
+            files: result.files.map((f) => ({
+                path: f.path,
+                sizeBytes: f.sizeBytes,
+                estimatedTokens: Math.round(f.sizeBytes / 4),
+            })),
+        }));
+        return;
+    }
+    console.log();
+    console.log(`  Benchmark: ${skillName}${meta?.version ? ` v${meta.version}` : ""}`);
+    console.log();
+    console.log(`  Files:            ${result.fileCount}`);
+    console.log(`  Total size:       ${formatKB(result.totalBytes)}`);
+    console.log(`  Est. tokens:      ${formatTokens(result.estimatedTokens)}`);
+    console.log(`  Context usage:    ${result.contextPercent.toFixed(2)}% of ${(CONTEXT_WINDOW_TOKENS / 1000).toFixed(0)}k window`);
+    console.log();
+    console.log("  File breakdown:");
+    console.log();
+    const sorted = [...result.files].sort((a, b) => b.sizeBytes - a.sizeBytes);
+    const maxPathLen = Math.min(Math.max(...sorted.map((f) => f.path.length)), 50);
+    for (const file of sorted) {
+        const displayPath = file.path.length > 50 ? file.path.slice(0, 47) + "..." : file.path;
+        const tokens = Math.round(file.sizeBytes / 4);
+        console.log(`    ${displayPath.padEnd(maxPathLen + 2)} ${formatKB(file.sizeBytes).padStart(10)}  ~${formatTokens(tokens).padStart(6)} tokens`);
+    }
+    console.log();
+}
+function benchmarkAll(installDir, json) {
+    let dirs;
+    try {
+        dirs = readdirSync(installDir).filter((d) => {
+            try {
+                return statSync(join(installDir, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        dirs = [];
+    }
+    if (dirs.length === 0) {
+        if (json) {
+            console.log(JSON.stringify({ skills: [], totalTokens: 0, totalBytes: 0 }));
+        }
+        else {
+            console.log("No skills installed.");
+        }
+        return;
+    }
+    const results = [];
+    for (const dir of dirs) {
+        const result = benchmarkSkill(dir);
+        if (result)
+            results.push(result);
+    }
+    results.sort((a, b) => b.estimatedTokens - a.estimatedTokens);
+    const totalBytes = results.reduce((sum, r) => sum + r.totalBytes, 0);
+    const totalTokens = results.reduce((sum, r) => sum + r.estimatedTokens, 0);
+    const totalContextPercent = (totalTokens / CONTEXT_WINDOW_TOKENS) * 100;
+    if (json) {
+        console.log(JSON.stringify({
+            skills: results.map((r) => ({
+                name: r.name,
+                fileCount: r.fileCount,
+                totalBytes: r.totalBytes,
+                estimatedTokens: r.estimatedTokens,
+                contextPercent: Math.round(r.contextPercent * 100) / 100,
+            })),
+            totalBytes,
+            totalTokens,
+            totalContextPercent: Math.round(totalContextPercent * 100) / 100,
+        }));
+        return;
+    }
+    console.log();
+    console.log(`  Benchmark: ${results.length} installed skill(s)`);
+    console.log();
+    const maxNameLen = Math.min(Math.max(...results.map((r) => r.name.length)), 30);
+    console.log(`  ${"Skill".padEnd(maxNameLen + 2)} ${"Files".padStart(5)}  ${"Size".padStart(10)}  ${"Tokens".padStart(8)}  ${"Context %".padStart(9)}`);
+    console.log(`  ${"-".repeat(maxNameLen + 2)} ${"-".repeat(5)}  ${"-".repeat(10)}  ${"-".repeat(8)}  ${"-".repeat(9)}`);
+    for (const r of results) {
+        const displayName = r.name.length > 30 ? r.name.slice(0, 27) + "..." : r.name;
+        console.log(`  ${displayName.padEnd(maxNameLen + 2)} ${String(r.fileCount).padStart(5)}  ${formatKB(r.totalBytes).padStart(10)}  ${formatTokens(r.estimatedTokens).padStart(8)}  ${r.contextPercent.toFixed(2).padStart(8)}%`);
+    }
+    console.log(`  ${"-".repeat(maxNameLen + 2)} ${"-".repeat(5)}  ${"-".repeat(10)}  ${"-".repeat(8)}  ${"-".repeat(9)}`);
+    console.log(`  ${"TOTAL".padEnd(maxNameLen + 2)} ${String(results.reduce((s, r) => s + r.fileCount, 0)).padStart(5)}  ${formatKB(totalBytes).padStart(10)}  ${formatTokens(totalTokens).padStart(8)}  ${totalContextPercent.toFixed(2).padStart(8)}%`);
+    console.log();
+    if (totalContextPercent > 50) {
+        console.log(`  Warning: installed skills consume ${totalContextPercent.toFixed(1)}% of context window.`);
+        console.log("  Consider removing unused skills with: arcana uninstall <skill>");
+        console.log();
+    }
+}

package/dist/commands/clean.d.ts

@@ -1,5 +1,6 @@
 export declare function cleanCommand(opts: {
     dryRun?: boolean;
+    aggressive?: boolean;
+    keepDays?: number;
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=clean.d.ts.map