@sporesec/arcana 3.0.2 → 4.0.0

package/dist/utils/scanner.js

@@ -270,20 +270,81 @@ const PATTERNS = [
     },
 ];
 // ---------------------------------------------------------------------------
-// Scanner
+// Scope detection: skip BAD/DON'T example blocks to reduce false positives
 // ---------------------------------------------------------------------------
+/** Detect if a line enters or exits a "BAD example" scope. */
+function isBadScopeStart(line) {
+    const trimmed = line.trim();
+    // Markdown headings: ### BAD, ### DON'T, ### Anti-pattern
+    if (/^#{1,4}\s+(?:BAD|DON'T|DONT|Anti-?pattern)/i.test(trimmed))
+        return true;
+    // Bold markers: **BAD**, **DON'T**
+    if (/^\*{2}(?:BAD|DON'T|DONT)\*{2}/i.test(trimmed))
+        return true;
+    // Code fence with bad label: ```bad, ```BAD
+    if (/^```\s*bad\b/i.test(trimmed))
+        return true;
+    // Inline label: BAD: or DON'T:
+    if (/^(?:BAD|DON'T|DONT)\s*:/i.test(trimmed))
+        return true;
+    return false;
+}
+function isBadScopeEnd(line, inCodeFence) {
+    const trimmed = line.trim();
+    // End of bad-labeled code fence
+    if (inCodeFence && trimmed === "```")
+        return true;
+    // New heading that isn't BAD
+    if (/^#{1,4}\s+/.test(trimmed) && !isBadScopeStart(trimmed))
+        return true;
+    // GOOD marker ends a BAD section
+    if (/^(?:\*{2}GOOD\*{2}|#{1,4}\s+GOOD)/i.test(trimmed))
+        return true;
+    return false;
+}
 /**
- * Scan SKILL.md content for security threats.
- * Returns an array of issues sorted by severity (critical first).
+ * Build a set of line indices that are inside BAD/DON'T example blocks.
+ * These lines should have their findings suppressed (not scanned) in default mode.
  */
-export function scanSkillContent(content) {
+function buildBadScopeSet(lines) {
+    const badLines = new Set();
+    let inBadScope = false;
+    let inBadCodeFence = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!inBadScope) {
+            if (isBadScopeStart(line)) {
+                inBadScope = true;
+                inBadCodeFence = /^```\s*bad\b/i.test(trimmed);
+                badLines.add(i);
+            }
+        }
+        else {
+            badLines.add(i);
+            if (isBadScopeEnd(line, inBadCodeFence)) {
+                inBadScope = false;
+                inBadCodeFence = false;
+            }
+        }
+    }
+    return badLines;
+}
+/**
+ * Scan with full result including suppressed findings.
+ * Used by scan command when --verbose is needed.
+ */
+export function scanSkillContentFull(content, options) {
     const issues = [];
+    const suppressed = [];
     const lines = content.split("\n");
+    const badScope = options?.strict ? new Set() : buildBadScopeSet(lines);
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
+        const target = badScope.has(i) && !options?.strict ? suppressed : issues;
         for (const pattern of PATTERNS) {
             if (pattern.regex.test(line)) {
-                issues.push({
+                target.push({
                     level: pattern.level,
                     category: pattern.category,
                     detail: pattern.detail,
@@ -298,11 +359,13 @@ export function scanSkillContent(content) {
         const line = lines[i];
         if (line.endsWith("\\")) {
             const joined = line.slice(0, -1) + " " + (lines[i + 1] ?? "").trim();
+            const target = badScope.has(i) && !options?.strict ? suppressed : issues;
             for (const pattern of PATTERNS) {
                 if (pattern.regex.test(joined)) {
                     const alreadyFound = issues.some((iss) => iss.line === i + 1 && iss.category === pattern.category);
-                    if (!alreadyFound) {
-                        issues.push({
+                    const alreadySuppressed = suppressed.some((iss) => iss.line === i + 1 && iss.category === pattern.category);
+                    if (!alreadyFound && !alreadySuppressed) {
+                        target.push({
                             level: pattern.level,
                             category: pattern.category,
                             detail: pattern.detail,
@@ -314,10 +377,19 @@ export function scanSkillContent(content) {
             }
         }
     }
-    // Sort: critical first, then high, then medium
     const order = { critical: 0, high: 1, medium: 2 };
     issues.sort((a, b) => order[a.level] - order[b.level]);
-    return issues;
+    suppressed.sort((a, b) => order[a.level] - order[b.level]);
+    return { issues, suppressed };
+}
+/**
+ * Scan SKILL.md content for security threats.
+ * Returns an array of issues sorted by severity (critical first).
+ * By default, findings inside BAD/DON'T example blocks are suppressed.
+ * Use strict mode to scan everything.
+ */
+export function scanSkillContent(content, options) {
+    return scanSkillContentFull(content, options).issues;
 }
 /**
  * Quick check: does this content have any critical issues?

package/dist/utils/sessions.d.ts

@@ -0,0 +1,2 @@
+/** Find the most recent session JSONL for the current project. */
+export declare function findLatestSession(cwd: string): string | null;

package/dist/utils/sessions.js

@@ -0,0 +1,36 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+/** Find the most recent session JSONL for the current project. */
+export function findLatestSession(cwd) {
+    const projectsDir = join(homedir(), ".claude", "projects");
+    if (!existsSync(projectsDir))
+        return null;
+    // Encode the project path the way Claude Code does
+    const encoded = cwd.replace(/[:/\\]/g, "-").replace(/^-+/, "");
+    const variants = [encoded, encoded.toLowerCase()];
+    for (const variant of variants) {
+        const projDir = join(projectsDir, variant);
+        if (!existsSync(projDir))
+            continue;
+        // Find newest .jsonl file
+        let newest = null;
+        try {
+            for (const file of readdirSync(projDir)) {
+                if (!file.endsWith(".jsonl"))
+                    continue;
+                const fullPath = join(projDir, file);
+                const stat = statSync(fullPath);
+                if (!newest || stat.mtimeMs > newest.mtime) {
+                    newest = { path: fullPath, mtime: stat.mtimeMs };
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+        if (newest)
+            return newest.path;
+    }
+    return null;
+}

package/dist/utils/ui.js

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 import ora from "ora";
+/* v8 ignore next 3 -- runtime color detection */
 if (process.env.NO_COLOR || process.env.TERM === "dumb") {
     chalk.level = 0;
 }
@@ -13,6 +14,7 @@ export const ui = {
     bold: (text) => chalk.bold(text),
     cyan: (text) => chalk.cyan(text),
 };
+/* v8 ignore start -- display-only functions */
 export function banner() {
     console.log();
     console.log(ui.brand("  arcana") + ui.dim(" - universal agent skill manager"));
@@ -21,6 +23,7 @@ export function banner() {
 export function spinner(text) {
     return ora({ text, color: "yellow" });
 }
+/* v8 ignore stop */
 export function noopSpinner() {
     return {
         start: () => { },
@@ -86,12 +89,14 @@ export function printErrorWithHint(err, showMessage = false) {
         }
     }
 }
+/* v8 ignore start -- display-only suggestion */
 export function suggest(text) {
     if (!process.stdout.isTTY)
         return;
     console.log(ui.dim("  Next: ") + text);
     console.log();
 }
+/* v8 ignore stop */
 export function errorAndExit(message, hint) {
     console.error();
     console.error(ui.error("  Error: ") + message);

package/dist/utils/usage.d.ts

@@ -0,0 +1,17 @@
+export interface SkillUsage {
+    loads: number;
+    curations: number;
+    lastUsed: string;
+    firstUsed: string;
+    projects: string[];
+}
+/** Record a skill load event. */
+export declare function recordLoad(skillName: string, project?: string): void;
+/** Record a skill curation event. */
+export declare function recordCuration(skillName: string): void;
+/** Get usage data for all skills. */
+export declare function getAllUsage(): Record<string, SkillUsage>;
+/** Get skills not used in the last N days. */
+export declare function getUnusedSkills(days: number): string[];
+/** Get usage boost score for a skill (for curation ranking). */
+export declare function getUsageBoost(skillName: string): number;

package/dist/utils/usage.js

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { atomicWriteSync } from "./atomic.js";
+function usagePath() {
+    return join(homedir(), ".arcana", "usage.json");
+}
+function readUsage() {
+    const p = usagePath();
+    if (!existsSync(p))
+        return {};
+    try {
+        return JSON.parse(readFileSync(p, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeUsage(data) {
+    const dir = join(homedir(), ".arcana");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    atomicWriteSync(usagePath(), JSON.stringify(data, null, 2));
+}
+function ensureEntry(data, skillName) {
+    if (!data[skillName]) {
+        data[skillName] = {
+            loads: 0,
+            curations: 0,
+            lastUsed: new Date().toISOString(),
+            firstUsed: new Date().toISOString(),
+            projects: [],
+        };
+    }
+    return data[skillName];
+}
+/** Record a skill load event. */
+export function recordLoad(skillName, project) {
+    const data = readUsage();
+    const entry = ensureEntry(data, skillName);
+    entry.loads++;
+    entry.lastUsed = new Date().toISOString();
+    if (project && !entry.projects.includes(project)) {
+        entry.projects.push(project);
+    }
+    writeUsage(data);
+}
+/** Record a skill curation event. */
+export function recordCuration(skillName) {
+    const data = readUsage();
+    const entry = ensureEntry(data, skillName);
+    entry.curations++;
+    entry.lastUsed = new Date().toISOString();
+    writeUsage(data);
+}
+/** Get usage data for all skills. */
+export function getAllUsage() {
+    return readUsage();
+}
+/** Get skills not used in the last N days. */
+export function getUnusedSkills(days) {
+    const data = readUsage();
+    const threshold = Date.now() - days * 24 * 60 * 60 * 1000;
+    return Object.entries(data)
+        .filter(([, u]) => new Date(u.lastUsed).getTime() < threshold)
+        .map(([name]) => name);
+}
+/** Get usage boost score for a skill (for curation ranking). */
+export function getUsageBoost(skillName) {
+    const data = readUsage();
+    const entry = data[skillName];
+    if (!entry)
+        return 0;
+    const daysSinceUse = (Date.now() - new Date(entry.lastUsed).getTime()) / (24 * 60 * 60 * 1000);
+    // Boost recently used skills, decay over 14 days
+    if (daysSinceUse < 1)
+        return 15;
+    if (daysSinceUse < 7)
+        return 10;
+    if (daysSinceUse < 14)
+        return 5;
+    return 0;
+}

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@sporesec/arcana",
-  "version": "3.0.2",
-  "description": "Universal AI development CLI. Skills, scaffolding, diagnostics, and analytics for every agent.",
+  "version": "4.0.0",
+  "description": "Context intelligence for AI coding agents. 74 skills, budget-aware curation, output compression, cross-session memory, MCP management. 7 platforms.",
   "bin": {
     "arcana": "dist/index.js"
   },
   "scripts": {
     "build": "tsc",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:check": "tsc --noEmit",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "test": "vitest run",
@@ -21,17 +23,49 @@
   "keywords": [
     "agent-skills",
     "claude",
+    "claude-code",
     "cursor",
     "codex",
+    "gemini",
+    "windsurf",
+    "aider",
+    "antigravity",
     "ai",
+    "ai-agents",
     "skills",
     "cli",
-    "diagnostics",
-    "scaffolding",
-    "analytics"
+    "context-management",
+    "token-optimization",
+    "mcp",
+    "developer-tools",
+    "automation",
+    "typescript",
+    "golang",
+    "python",
+    "react",
+    "nextjs",
+    "devops",
+    "security",
+    "testing",
+    "compression",
+    "curation"
+  ],
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Medy Gribkov",
+    "email": "medy@sporesec.com",
+    "url": "https://sporesec.com"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/medy-gribkov"
+    },
+    {
+      "type": "individual",
+      "url": "https://buymeacoffee.com/medygribkov"
+    }
   ],
-  "license": "MIT",
-  "author": "Mahdy Gribkov",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/medy-gribkov/arcana.git",
@@ -65,6 +99,7 @@
     "@types/node": "^25.3.0",
     "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^4.0.18",
+    "esbuild": "^0.27.3",
     "eslint": "^10.0.2",
     "prettier": "^3.8.1",
     "typescript": "^5.7.3",

package/dist/command-registry.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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/benchmark.d.ts

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

package/dist/commands/benchmark.js

@@ -1,178 +0,0 @@
-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/compact.d.ts

@@ -1,6 +0,0 @@
-export declare function compactCommand(opts: {
-    dryRun?: boolean;
-    json?: boolean;
-    prune?: boolean;
-    pruneDays?: number;
-}): Promise<void>;