@sporesec/arcana 2.3.1 → 3.0.0

package/dist/commands/clean.js

@@ -2,49 +2,88 @@ import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { ui, banner } from "../utils/ui.js";
-import { getDirSize, listSymlinks } from "../utils/fs.js";
+import { getDirSize, listSymlinks, isOrphanedProject } from "../utils/fs.js";
 import { clearHistory } from "../utils/history.js";
+import { STALE_PROJECT_DAYS, AGENT_LOG_MAX_AGE_DAYS, MAIN_LOG_MAX_AGE_DAYS } from "../constants.js";
+const AUXILIARY_DIRS = ["file-history", "debug", "shell-snapshots", "todos", "plans"];
+function purgeDir(dir, dryRun) {
+    if (!existsSync(dir))
+        return 0;
+    let reclaimed = 0;
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        try {
+            const stat = statSync(full);
+            reclaimed += stat.isDirectory() ? getDirSize(full) : stat.size;
+            if (!dryRun)
+                rmSync(full, { recursive: true, force: true });
+        }
+        catch {
+            /* skip locked files */
+        }
+    }
+    return reclaimed;
+}
+function isAgentLog(filename) {
+    return filename.startsWith("agent-") && filename.endsWith(".jsonl");
+}
 export async function cleanCommand(opts) {
     if (!opts.json)
         banner();
     const dryRun = opts.dryRun ?? false;
+    const aggressive = opts.aggressive ?? false;
+    const keepDays = opts.keepDays ?? MAIN_LOG_MAX_AGE_DAYS;
+    const agentKeepDays = aggressive ? 0 : AGENT_LOG_MAX_AGE_DAYS;
+    const mainKeepDays = aggressive ? 0 : keepDays;
     if (dryRun && !opts.json)
         console.log(ui.warn("  DRY RUN - no files will be deleted\n"));
-    let totalReclaimed = 0;
-    let actions = 0;
-    const removedSymlinks = [];
-    const removedProjects = [];
-    const removedCacheFiles = [];
+    if (aggressive && !opts.json)
+        console.log(ui.warn("  AGGRESSIVE MODE - all session logs will be targeted\n"));
+    const result = {
+        dryRun,
+        actions: 0,
+        reclaimedBytes: 0,
+        removedSymlinks: [],
+        removedProjects: [],
+        removedCacheFiles: [],
+        removedSessionLogs: [],
+        purgedDirs: [],
+    };
     // 1. Clean broken symlinks
     const failedSymlinks = [];
-    for (const link of listSymlinks().filter(s => s.broken)) {
+    if (!opts.json)
+        console.log(ui.bold("  Symlinks"));
+    for (const link of listSymlinks().filter((s) => s.broken)) {
         if (!dryRun) {
             try {
                 rmSync(link.fullPath);
             }
             catch (err) {
                 if (!opts.json)
-                    console.log(`  ${ui.warn("Could not remove symlink:")} ${link.name} ${ui.dim(`(${err instanceof Error ? err.message : "unknown error"})`)}`);
+                    console.log(`  ${ui.warn("  Could not remove:")} ${link.name} ${ui.dim(`(${err instanceof Error ? err.message : "unknown"})`)}`);
                 failedSymlinks.push(link.name);
                 continue;
             }
         }
         if (!opts.json)
-            console.log(`  ${ui.dim("Remove broken symlink:")} ${link.name}`);
-        removedSymlinks.push(link.name);
-        actions++;
+            console.log(`  ${ui.dim("  Remove broken:")} ${link.name}`);
+        result.removedSymlinks.push(link.name);
+        result.actions++;
     }
-    // 2. Clean orphaned Claude project dirs
+    if (result.removedSymlinks.length === 0 && !opts.json)
+        console.log(ui.dim("    No broken symlinks"));
+    // 2. Clean orphaned + stale project dirs
+    if (!opts.json)
+        console.log(ui.bold("\n  Project Data"));
     const projectsDir = join(homedir(), ".claude", "projects");
     if (existsSync(projectsDir)) {
         for (const entry of readdirSync(projectsDir)) {
             const projDir = join(projectsDir, entry);
             if (!statSync(projDir).isDirectory())
                 continue;
-            // Skip memory/ and other special dirs
             if (entry === "memory" || entry.startsWith("."))
                 continue;
-            // Check for session data staleness (no files modified in 90+ days)
+            const orphaned = isOrphanedProject(entry);
             let newest = 0;
             try {
                 for (const file of readdirSync(projDir)) {
@@ -57,26 +96,148 @@ export async function cleanCommand(opts) {
                 continue;
             }
             const daysOld = (Date.now() - newest) / (1000 * 60 * 60 * 24);
-            if (daysOld > 90) {
+            const shouldRemove = orphaned || daysOld > STALE_PROJECT_DAYS;
+            if (shouldRemove) {
                 const size = getDirSize(projDir);
-                totalReclaimed += size;
+                result.reclaimedBytes += size;
                 const mb = (size / (1024 * 1024)).toFixed(1);
+                const reason = orphaned ? "orphaned (source deleted)" : `stale (${Math.floor(daysOld)}d old)`;
                 if (!dryRun)
                     rmSync(projDir, { recursive: true, force: true });
                 if (!opts.json)
-                    console.log(`  ${ui.dim("Remove stale project data:")} ${entry} ${ui.dim(`(${mb} MB, ${Math.floor(daysOld)}d old)`)}`);
-                removedProjects.push({ name: entry, sizeMB: mb, daysOld: Math.floor(daysOld) });
-                actions++;
+                    console.log(`    ${ui.dim("Remove:")} ${entry} ${ui.dim(`(${mb} MB, ${reason})`)}`);
+                result.removedProjects.push({ name: entry, sizeMB: mb, reason });
+                result.actions++;
+            }
+        }
+    }
+    if (result.removedProjects.length === 0 && !opts.json)
+        console.log(ui.dim("    No orphaned or stale projects"));
+    // 3. Tiered session log cleanup
+    // - Agent logs (agent-*.jsonl): delete after 7 days (never resumed, bulk of bloat)
+    // - Main sessions (UUID.jsonl): delete after 30 days (configurable with --keep-days)
+    // - Aggressive mode: delete everything regardless of age
+    if (!opts.json) {
+        console.log(ui.bold("\n  Session Logs"));
+        if (!aggressive) {
+            console.log(ui.dim(`    Agent logs: remove >${agentKeepDays}d | Main sessions: remove >${mainKeepDays}d`));
+        }
+    }
+    let logCount = 0;
+    if (existsSync(projectsDir)) {
+        const now = Date.now();
+        for (const entry of readdirSync(projectsDir)) {
+            const projDir = join(projectsDir, entry);
+            if (!statSync(projDir).isDirectory())
+                continue;
+            if (entry === "memory" || entry.startsWith("."))
+                continue;
+            // Scan all files in project dir (not recursive, JSONL files are at top level)
+            for (const file of readdirSync(projDir)) {
+                if (!file.endsWith(".jsonl"))
+                    continue;
+                const fullPath = join(projDir, file);
+                let stat;
+                try {
+                    stat = statSync(fullPath);
+                }
+                catch {
+                    continue;
+                }
+                const daysOld = (now - stat.mtimeMs) / (1000 * 60 * 60 * 24);
+                const isAgent = isAgentLog(file);
+                const maxAge = isAgent ? agentKeepDays : mainKeepDays;
+                if (daysOld > maxAge) {
+                    const sizeMB = stat.size / (1024 * 1024);
+                    result.reclaimedBytes += stat.size;
+                    if (!dryRun) {
+                        try {
+                            rmSync(fullPath, { force: true });
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                    const reason = isAgent ? "agent log" : "main session";
+                    if (!opts.json)
+                        console.log(`    ${ui.dim("Remove:")} ${entry}/${file} ${ui.dim(`(${sizeMB.toFixed(1)} MB, ${Math.floor(daysOld)}d, ${reason})`)}`);
+                    result.removedSessionLogs.push({
+                        project: entry,
+                        file,
+                        sizeMB: sizeMB.toFixed(1),
+                        daysOld: Math.floor(daysOld),
+                        reason,
+                    });
+                    logCount++;
+                    result.actions++;
+                }
+            }
+            // Also clean agent subdirectories (UUID dirs containing agent subfiles)
+            for (const sub of readdirSync(projDir)) {
+                const subPath = join(projDir, sub);
+                try {
+                    if (!statSync(subPath).isDirectory())
+                        continue;
+                    if (sub === "memory")
+                        continue;
+                    // Check if directory is old enough
+                    const stat = statSync(subPath);
+                    const daysOld = (now - stat.mtimeMs) / (1000 * 60 * 60 * 24);
+                    if (daysOld > agentKeepDays) {
+                        const size = getDirSize(subPath);
+                        if (size === 0)
+                            continue;
+                        result.reclaimedBytes += size;
+                        if (!dryRun)
+                            rmSync(subPath, { recursive: true, force: true });
+                        const mb = (size / (1024 * 1024)).toFixed(1);
+                        if (!opts.json)
+                            console.log(`    ${ui.dim("Remove:")} ${entry}/${sub}/ ${ui.dim(`(${mb} MB, ${Math.floor(daysOld)}d, session dir)`)}`);
+                        result.removedSessionLogs.push({
+                            project: entry,
+                            file: sub + "/",
+                            sizeMB: mb,
+                            daysOld: Math.floor(daysOld),
+                            reason: "session dir",
+                        });
+                        logCount++;
+                        result.actions++;
+                    }
+                }
+                catch {
+                    continue;
+                }
             }
         }
     }
-    // 3. Clear action history
+    if (logCount === 0 && !opts.json)
+        console.log(ui.dim("    No session logs to trim"));
+    // 4. Purge auxiliary directories
+    if (!opts.json)
+        console.log(ui.bold("\n  Auxiliary Data"));
+    const claudeDir = join(homedir(), ".claude");
+    for (const dirName of AUXILIARY_DIRS) {
+        const dir = join(claudeDir, dirName);
+        if (!existsSync(dir))
+            continue;
+        const size = getDirSize(dir);
+        if (size === 0)
+            continue;
+        const mb = (size / (1024 * 1024)).toFixed(1);
+        const reclaimed = dryRun ? size : purgeDir(dir, false);
+        result.reclaimedBytes += reclaimed;
+        if (!opts.json)
+            console.log(`    ${ui.dim("Purge:")} ${dirName}/ ${ui.dim(`(${mb} MB)`)}`);
+        result.purgedDirs.push({ name: dirName, sizeMB: mb });
+        result.actions++;
+    }
+    if (result.purgedDirs.length === 0 && !opts.json)
+        console.log(ui.dim("    All clean"));
+    // 5. Clear action history
     if (!dryRun)
         clearHistory();
-    if (!opts.json)
-        console.log(`  ${ui.dim("Clear action history")}`);
-    actions++;
-    // 4. Clean disk cache
+    result.actions++;
+    // 6. Clean disk cache
     const cacheDir = join(homedir(), ".arcana", "cache");
     if (existsSync(cacheDir)) {
         for (const file of readdirSync(cacheDir)) {
@@ -88,38 +249,28 @@ export async function cleanCommand(opts) {
                     continue;
                 }
             }
-            if (!opts.json)
-                console.log(`  ${ui.dim("Remove cached data:")} ${file}`);
-            removedCacheFiles.push(file);
-            actions++;
+            result.removedCacheFiles.push(file);
+            result.actions++;
         }
     }
+    if (failedSymlinks.length > 0)
+        result.failedSymlinks = failedSymlinks;
+    // Output
     if (opts.json) {
-        const result = {
-            dryRun,
-            actions,
-            reclaimedMB: Number((totalReclaimed / (1024 * 1024)).toFixed(1)),
-            removedSymlinks,
-            removedProjects,
-            removedCacheFiles,
-        };
-        if (failedSymlinks.length > 0)
-            result.failedSymlinks = failedSymlinks;
-        console.log(JSON.stringify(result));
+        console.log(JSON.stringify({
+            ...result,
+            reclaimedMB: Number((result.reclaimedBytes / (1024 * 1024)).toFixed(1)),
+        }, null, 2));
         return;
     }
     console.log();
-    if (actions > 0) {
-        const mb = (totalReclaimed / (1024 * 1024)).toFixed(1);
-        const verb = dryRun ? "Would reclaim" : "Reclaimed";
-        console.log(ui.success(`  ${actions} items cleaned. ${verb} ${mb} MB.`));
+    const mb = (result.reclaimedBytes / (1024 * 1024)).toFixed(1);
+    const verb = dryRun ? "Would reclaim" : "Reclaimed";
+    if (result.actions > 1) {
+        console.log(ui.success(`  ${result.actions} items cleaned. ${verb} ${mb} MB.`));
     }
     else {
-        console.log(ui.dim("  Checked:"));
-        console.log(ui.dim(`  - Broken symlinks in ~/.claude/skills/: ${removedSymlinks.length} found`));
-        console.log(ui.dim(`  - Stale project data in ~/.claude/projects/: ${removedProjects.length} found`));
         console.log(ui.success("  Nothing to clean."));
     }
     console.log();
 }
-//# sourceMappingURL=clean.js.map

package/dist/commands/compact.d.ts

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

package/dist/commands/compact.js

@@ -0,0 +1,239 @@
+import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { ui, banner } from "../utils/ui.js";
+import { getDirSize } from "../utils/fs.js";
+import { PRUNE_DEFAULT_DAYS, PRUNE_SIZE_THRESHOLD_BYTES, PRUNE_KEEP_NEWEST } from "../constants.js";
+function analyzeProject(projDir, projName) {
+    const now = Date.now();
+    const mainFiles = [];
+    const agentFiles = [];
+    const sessionDirs = [];
+    for (const entry of readdirSync(projDir)) {
+        const full = join(projDir, entry);
+        try {
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                if (entry === "memory")
+                    continue;
+                sessionDirs.push({
+                    name: entry,
+                    sizeBytes: getDirSize(full),
+                    daysOld: Math.floor((now - stat.mtimeMs) / (1000 * 60 * 60 * 24)),
+                });
+                continue;
+            }
+            if (!entry.endsWith(".jsonl"))
+                continue;
+            const info = {
+                name: entry,
+                sizeBytes: stat.size,
+                daysOld: Math.floor((now - stat.mtimeMs) / (1000 * 60 * 60 * 24)),
+            };
+            if (entry.startsWith("agent-")) {
+                agentFiles.push(info);
+            }
+            else {
+                mainFiles.push(info);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    const totalBytes = mainFiles.reduce((s, f) => s + f.sizeBytes, 0) +
+        agentFiles.reduce((s, f) => s + f.sizeBytes, 0) +
+        sessionDirs.reduce((s, d) => s + d.sizeBytes, 0);
+    // Reclaimable: all agent files + all session dirs
+    const reclaimableBytes = agentFiles.reduce((s, f) => s + f.sizeBytes, 0) + sessionDirs.reduce((s, d) => s + d.sizeBytes, 0);
+    return { name: projName, mainFiles, agentFiles, sessionDirs, totalBytes, reclaimableBytes };
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+/**
+ * Prune oversized main session files.
+ * Targets files older than pruneDays AND larger than 10 MB.
+ * Always keeps the 3 newest sessions per project regardless.
+ */
+function pruneMainSessions(analyses, projectsDir, pruneDays, dryRun, json) {
+    const pruned = [];
+    let reclaimedBytes = 0;
+    for (const a of analyses) {
+        // Sort main files by age (newest first) to protect the 3 newest
+        const sorted = [...a.mainFiles].sort((x, y) => x.daysOld - y.daysOld);
+        const candidates = sorted.slice(PRUNE_KEEP_NEWEST); // Skip the 3 newest
+        for (const f of candidates) {
+            if (f.daysOld > pruneDays && f.sizeBytes > PRUNE_SIZE_THRESHOLD_BYTES) {
+                const sizeMB = (f.sizeBytes / (1024 * 1024)).toFixed(1);
+                if (!json) {
+                    console.log(`    ${ui.warn("Prune:")} ${f.name} ${ui.dim(`(${sizeMB} MB, ${f.daysOld}d old)`)}`);
+                }
+                if (!dryRun) {
+                    try {
+                        rmSync(join(projectsDir, a.name, f.name), { force: true });
+                    }
+                    catch {
+                        /* skip */
+                    }
+                }
+                pruned.push({ project: a.name, file: f.name, sizeMB, daysOld: f.daysOld });
+                reclaimedBytes += f.sizeBytes;
+            }
+        }
+    }
+    return { pruned, reclaimedBytes };
+}
+export async function compactCommand(opts) {
+    if (!opts.json)
+        banner();
+    const dryRun = opts.dryRun ?? false;
+    if (dryRun && !opts.json)
+        console.log(ui.warn("  DRY RUN - no files will be deleted\n"));
+    const projectsDir = join(homedir(), ".claude", "projects");
+    if (!existsSync(projectsDir)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ projects: [], totalReclaimed: 0 }));
+        }
+        else {
+            console.log(ui.dim("  No session data found."));
+            console.log();
+        }
+        return;
+    }
+    const analyses = [];
+    for (const entry of readdirSync(projectsDir)) {
+        const projDir = join(projectsDir, entry);
+        if (!statSync(projDir).isDirectory())
+            continue;
+        if (entry === "memory" || entry.startsWith("."))
+            continue;
+        const analysis = analyzeProject(projDir, entry);
+        if (analysis.totalBytes > 0) {
+            analyses.push(analysis);
+        }
+    }
+    analyses.sort((a, b) => b.totalBytes - a.totalBytes);
+    if (opts.json) {
+        const jsonResult = {
+            projects: analyses.map((a) => ({
+                name: a.name,
+                totalBytes: a.totalBytes,
+                reclaimableBytes: a.reclaimableBytes,
+                mainSessions: a.mainFiles.length,
+                agentLogs: a.agentFiles.length,
+                sessionDirs: a.sessionDirs.length,
+            })),
+            totalReclaimed: dryRun ? 0 : analyses.reduce((s, a) => s + a.reclaimableBytes, 0),
+        };
+        if (!dryRun) {
+            for (const a of analyses) {
+                const projDir = join(projectsDir, a.name);
+                for (const f of a.agentFiles) {
+                    try {
+                        rmSync(join(projDir, f.name), { force: true });
+                    }
+                    catch {
+                        /* skip */
+                    }
+                }
+                for (const d of a.sessionDirs) {
+                    try {
+                        rmSync(join(projDir, d.name), { recursive: true, force: true });
+                    }
+                    catch {
+                        /* skip */
+                    }
+                }
+            }
+        }
+        if (opts.prune) {
+            const pruneDays = opts.pruneDays ?? PRUNE_DEFAULT_DAYS;
+            const pruneResult = pruneMainSessions(analyses, projectsDir, pruneDays, dryRun, true);
+            jsonResult.pruned = pruneResult.pruned;
+            jsonResult.prunedBytes = pruneResult.reclaimedBytes;
+            if (!dryRun) {
+                jsonResult.totalReclaimed = jsonResult.totalReclaimed + pruneResult.reclaimedBytes;
+            }
+        }
+        console.log(JSON.stringify(jsonResult, null, 2));
+        return;
+    }
+    if (!opts.json)
+        console.log(ui.bold("  Session Compaction Report\n"));
+    let totalReclaimed = 0;
+    const hasWork = analyses.some((a) => a.reclaimableBytes > 0);
+    for (const a of analyses) {
+        if (a.totalBytes < 1024)
+            continue; // Skip tiny projects
+        const truncName = a.name.length > 50 ? a.name.slice(0, 47) + "..." : a.name;
+        console.log(`  ${ui.bold(truncName)}  ${ui.dim(formatBytes(a.totalBytes))}`);
+        // Main sessions
+        const mainSize = a.mainFiles.reduce((s, f) => s + f.sizeBytes, 0);
+        console.log(`    ${ui.success("Keep:")} ${a.mainFiles.length} main session${a.mainFiles.length !== 1 ? "s" : ""} ${ui.dim(`(${formatBytes(mainSize)})`)}`);
+        // Agent logs
+        if (a.agentFiles.length > 0) {
+            const agentSize = a.agentFiles.reduce((s, f) => s + f.sizeBytes, 0);
+            console.log(`    ${ui.warn("Remove:")} ${a.agentFiles.length} agent log${a.agentFiles.length !== 1 ? "s" : ""} ${ui.dim(`(${formatBytes(agentSize)})`)}`);
+            if (!dryRun) {
+                const projDir = join(projectsDir, a.name);
+                for (const f of a.agentFiles) {
+                    try {
+                        rmSync(join(projDir, f.name), { force: true });
+                    }
+                    catch {
+                        /* skip */
+                    }
+                }
+            }
+            totalReclaimed += agentSize;
+        }
+        // Session dirs
+        if (a.sessionDirs.length > 0) {
+            const dirSize = a.sessionDirs.reduce((s, d) => s + d.sizeBytes, 0);
+            if (dirSize > 0) {
+                console.log(`    ${ui.warn("Remove:")} ${a.sessionDirs.length} session dir${a.sessionDirs.length !== 1 ? "s" : ""} ${ui.dim(`(${formatBytes(dirSize)})`)}`);
+                if (!dryRun) {
+                    const projDir = join(projectsDir, a.name);
+                    for (const d of a.sessionDirs) {
+                        try {
+                            rmSync(join(projDir, d.name), { recursive: true, force: true });
+                        }
+                        catch {
+                            /* skip */
+                        }
+                    }
+                }
+                totalReclaimed += dirSize;
+            }
+        }
+        console.log();
+    }
+    // Prune oversized main sessions if requested
+    if (opts.prune) {
+        const pruneDays = opts.pruneDays ?? PRUNE_DEFAULT_DAYS;
+        console.log(ui.bold(`  Pruning main sessions (>${pruneDays}d old AND >10 MB, keeping 3 newest per project)\n`));
+        const pruneResult = pruneMainSessions(analyses, projectsDir, pruneDays, dryRun, false);
+        totalReclaimed += pruneResult.reclaimedBytes;
+        if (pruneResult.pruned.length === 0) {
+            console.log(ui.dim("    No oversized sessions to prune."));
+        }
+        console.log();
+    }
+    // Summary
+    if (!hasWork && !opts.prune) {
+        console.log(ui.success("  Already compact. No agent logs to remove."));
+    }
+    else {
+        const verb = dryRun ? "Would reclaim" : "Reclaimed";
+        console.log(ui.success(`  ${verb} ${formatBytes(totalReclaimed)} by removing agent logs and session dirs.`));
+        console.log(ui.dim("  Main session files preserved for history."));
+    }
+    console.log();
+}

package/dist/commands/completions.d.ts

@@ -0,0 +1,3 @@
+export declare function completionsCommand(shell: string, opts: {
+    json?: boolean;
+}): void;

package/dist/commands/completions.js

@@ -0,0 +1,104 @@
+const BASH_COMPLETIONS = `# arcana bash completion
+_arcana_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local commands="list install info search providers create validate update uninstall init doctor clean compact stats config audit scan optimize verify lock profile benchmark diff outdated team export import completions"
+
+  if [ "\${COMP_CWORD}" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+  fi
+}
+complete -F _arcana_completions arcana
+`;
+const ZSH_COMPLETIONS = `#compdef arcana
+_arcana() {
+  local -a commands
+  commands=(
+    'list:List available skills'
+    'install:Install one or more skills'
+    'info:Show skill details'
+    'search:Search for skills'
+    'providers:Manage skill providers'
+    'create:Create a new skill'
+    'validate:Validate skill structure'
+    'update:Update installed skills'
+    'uninstall:Uninstall skills'
+    'init:Initialize arcana in project'
+    'doctor:Check environment'
+    'clean:Remove orphaned data'
+    'compact:Remove agent logs'
+    'stats:Show session analytics'
+    'config:View or modify config'
+    'audit:Audit skill quality'
+    'scan:Scan for security threats'
+    'optimize:Suggest improvements'
+    'verify:Verify skill integrity'
+    'lock:Manage lockfile'
+    'profile:Manage skill profiles'
+    'benchmark:Measure token cost'
+    'diff:Show skill changes'
+    'outdated:List outdated skills'
+    'team:Team skill management'
+    'export:Export skill manifest'
+    'import:Import skills'
+    'completions:Generate shell completions'
+  )
+  _describe 'command' commands
+}
+_arcana
+`;
+const FISH_COMPLETIONS = `# arcana fish completion
+set -l commands list install info search providers create validate update uninstall init doctor clean compact stats config audit scan optimize verify lock profile benchmark diff outdated team export import completions
+complete -c arcana -f
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a list -d "List available skills"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a install -d "Install skills"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a info -d "Show skill details"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a search -d "Search for skills"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a providers -d "Manage providers"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a create -d "Create a skill"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a validate -d "Validate skills"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a update -d "Update skills"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a uninstall -d "Uninstall skills"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a init -d "Initialize arcana"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a doctor -d "Check environment"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a clean -d "Remove orphaned data"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a compact -d "Remove agent logs"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a stats -d "Session analytics"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a config -d "View/modify config"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a audit -d "Audit skill quality"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a scan -d "Security scan"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a optimize -d "Suggest improvements"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a verify -d "Verify integrity"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a lock -d "Manage lockfile"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a profile -d "Skill profiles"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a benchmark -d "Measure token cost"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a diff -d "Show skill changes"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a outdated -d "List outdated skills"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a team -d "Team management"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a export -d "Export manifest"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a import -d "Import skills"
+complete -c arcana -n "not __fish_seen_subcommand_from $commands" -a completions -d "Shell completions"
+`;
+const SHELLS = {
+    bash: BASH_COMPLETIONS,
+    zsh: ZSH_COMPLETIONS,
+    fish: FISH_COMPLETIONS,
+};
+export function completionsCommand(shell, opts) {
+    const supported = Object.keys(SHELLS);
+    if (!supported.includes(shell)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: `Unsupported shell: ${shell}`, supported }));
+        }
+        else {
+            console.error(`Unsupported shell: ${shell}`);
+            console.error(`Supported: ${supported.join(", ")}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ shell, script: SHELLS[shell] }));
+    }
+    else {
+        console.log(SHELLS[shell]);
+    }
+}

package/dist/commands/config.d.ts

@@ -1,4 +1,3 @@
 export declare function configCommand(action: string | undefined, value: string | undefined, opts?: {
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=config.d.ts.map