@sporesec/arcana 3.0.2 → 4.0.0

package/dist/commands/doctor.js

@@ -1,9 +1,49 @@
-import { existsSync, readdirSync, readFileSync, statSync, openSync, readSync, closeSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync, openSync, readSync, closeSync, mkdirSync, rmSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { execSync } from "node:child_process";
 import { ui, banner, suggest } from "../utils/ui.js";
 import { getInstallDir, getDirSize, listSymlinks, isOrphanedProject } from "../utils/fs.js";
+/** Auto-fix a doctor check. Returns true if fixed. */
+function autoFix(check) {
+    try {
+        switch (check.name) {
+            case "Skills directory": {
+                const dir = getInstallDir();
+                if (!existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                    return true;
+                }
+                return false;
+            }
+            case "Symlinks": {
+                const broken = listSymlinks().filter((s) => s.broken);
+                for (const s of broken) {
+                    try {
+                        rmSync(s.fullPath);
+                    }
+                    catch {
+                        /* skip */
+                    }
+                }
+                return broken.length > 0;
+            }
+            case "Arcana config": {
+                const configPath = join(homedir(), ".arcana", "config.json");
+                const dir = join(homedir(), ".arcana");
+                if (!existsSync(dir))
+                    mkdirSync(dir, { recursive: true });
+                writeFileSync(configPath, JSON.stringify({ defaultProvider: "arcana", providers: [] }, null, 2));
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
 function checkNodeVersion() {
     const major = parseInt(process.version.slice(1));
     if (major >= 18) {
@@ -300,10 +340,12 @@ export function runDoctorChecks() {
     ];
 }
 export async function doctorCommand(opts = {}) {
+    /* v8 ignore start */
     if (!opts.json) {
         banner();
         console.log(ui.bold("  Environment Health Check\n"));
     }
+    /* v8 ignore stop */
     const checks = runDoctorChecks();
     if (opts.json) {
         console.log(JSON.stringify({
@@ -316,16 +358,32 @@ export async function doctorCommand(opts = {}) {
         }, null, 2));
         return;
     }
+    /* v8 ignore start */
+    let fixed = 0;
     for (const check of checks) {
         const icon = check.status === "pass" ? ui.success("[OK]") : check.status === "warn" ? ui.warn("[!!]") : ui.error("[XX]");
         console.log(`  ${icon} ${ui.bold(check.name)}: ${check.message}`);
-        if (check.fix) {
+        // Auto-fix if --fix flag and check has issues
+        if (opts.fix && check.status !== "pass" && check.fix) {
+            const wasFixed = autoFix(check);
+            if (wasFixed) {
+                console.log(ui.success(`    Fixed automatically`));
+                fixed++;
+            }
+            else {
+                console.log(ui.dim(`    Manual fix: ${check.fix}`));
+            }
+        }
+        else if (check.fix && !opts.fix) {
             console.log(ui.dim(`    Fix: ${check.fix}`));
         }
     }
     const fails = checks.filter((c) => c.status === "fail").length;
     const warns = checks.filter((c) => c.status === "warn").length;
     console.log();
+    if (opts.fix && fixed > 0) {
+        console.log(ui.success(`  Auto-fixed ${fixed} issue${fixed > 1 ? "s" : ""}`));
+    }
     if (fails > 0) {
         console.log(ui.error(`  ${fails} issue${fails > 1 ? "s" : ""} found`));
     }
@@ -339,4 +397,5 @@ export async function doctorCommand(opts = {}) {
     if (fails === 0 && warns === 0) {
         suggest("arcana list");
     }
+    /* v8 ignore stop */
 }

package/dist/commands/import-cmd.js

@@ -33,6 +33,7 @@ export async function importCommand(file, opts) {
             console.log(JSON.stringify({ error: `File not found: ${file}` }));
         }
         else {
+            /* v8 ignore next */
             console.error(`Error: File not found: ${file}`);
         }
         process.exit(1);
@@ -76,6 +77,7 @@ export async function importCommand(file, opts) {
             failed.push(entry.name);
             errors[entry.name] = msg;
             if (!opts.json) {
+                /* v8 ignore next */
                 console.error(`Skipping ${entry.name}: ${msg}`);
             }
             continue;
@@ -105,6 +107,7 @@ export async function importCommand(file, opts) {
             updateLockEntry(entry.name, version, provider.name, files);
             installed.push(entry.name);
             if (!opts.json) {
+                /* v8 ignore next */
                 console.log(`Installed ${entry.name}`);
             }
         }
@@ -113,6 +116,7 @@ export async function importCommand(file, opts) {
             failed.push(entry.name);
             errors[entry.name] = msg;
             if (!opts.json) {
+                /* v8 ignore next */
                 console.error(`Failed to install ${entry.name}: ${msg}`);
             }
         }
@@ -124,6 +128,7 @@ export async function importCommand(file, opts) {
         console.log(JSON.stringify(result));
     }
     else {
+        /* v8 ignore next */
         console.log(`Import complete: ${installed.length} installed, ${skipped.length} skipped, ${failed.length} failed`);
     }
     if (failed.length > 0)

package/dist/commands/index.d.ts

@@ -0,0 +1,5 @@
+/** Regenerate the skill index file. Returns the number of skills indexed. */
+export declare function regenerateIndex(): number;
+export declare function indexCommand(opts: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/index.js

@@ -0,0 +1,107 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getInstallDir } from "../utils/fs.js";
+import { atomicWriteSync } from "../utils/atomic.js";
+import { INDEX_FILENAME } from "../constants.js";
+import { ui, banner } from "../utils/ui.js";
+/** Parse frontmatter description from a SKILL.md file. */
+function extractDescription(skillDir) {
+    const skillMd = join(skillDir, "SKILL.md");
+    if (!existsSync(skillMd))
+        return "";
+    try {
+        const content = readFileSync(skillMd, "utf-8");
+        const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (!match)
+            return "";
+        const fmLine = match[1].split("\n").find((l) => l.startsWith("description:"));
+        if (!fmLine)
+            return "";
+        // Strip quotes and trim
+        return fmLine
+            .replace(/^description:\s*/, "")
+            .replace(/^["']|["']$/g, "")
+            .trim();
+    }
+    catch {
+        return "";
+    }
+}
+/** Collect all installed skills with their descriptions. */
+function collectSkillEntries() {
+    const installDir = getInstallDir();
+    if (!existsSync(installDir))
+        return [];
+    const entries = [];
+    for (const name of readdirSync(installDir).sort()) {
+        const skillDir = join(installDir, name);
+        try {
+            if (!statSync(skillDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        // Skip index and loaded files
+        if (name.startsWith("_"))
+            continue;
+        const description = extractDescription(skillDir);
+        entries.push({ name, description });
+    }
+    return entries;
+}
+/** Generate the index markdown content. */
+function generateIndexContent(entries) {
+    const lines = [];
+    lines.push(`# Installed Skills (${entries.length})`);
+    lines.push("");
+    lines.push("| Skill | Description |");
+    lines.push("|-------|-------------|");
+    for (const entry of entries) {
+        // Truncate description to keep index compact
+        const desc = entry.description.length > 120 ? entry.description.slice(0, 117) + "..." : entry.description;
+        lines.push(`| ${entry.name} | ${desc} |`);
+    }
+    lines.push("");
+    lines.push("To load a skill into context: `arcana load <skill-name>`");
+    lines.push("");
+    return lines.join("\n");
+}
+/** Regenerate the skill index file. Returns the number of skills indexed. */
+export function regenerateIndex() {
+    const entries = collectSkillEntries();
+    const installDir = getInstallDir();
+    if (!existsSync(installDir))
+        return 0;
+    const indexPath = join(installDir, INDEX_FILENAME);
+    const content = generateIndexContent(entries);
+    atomicWriteSync(indexPath, content, 0o644);
+    return entries.length;
+}
+export async function indexCommand(opts) {
+    if (!opts.json) {
+        banner();
+        console.log(ui.bold("  Skill Index\n"));
+    }
+    const count = regenerateIndex();
+    const installDir = getInstallDir();
+    const indexPath = join(installDir, INDEX_FILENAME);
+    if (opts.json) {
+        console.log(JSON.stringify({
+            indexed: count,
+            path: indexPath,
+        }));
+        return;
+    }
+    if (count === 0) {
+        console.log(ui.dim("  No skills installed."));
+    }
+    else {
+        console.log(ui.success(`  [OK]`) + ` Indexed ${count} skills`);
+        console.log(ui.dim(`  Path: ${indexPath}`));
+        console.log();
+        console.log(ui.dim("  Agents load this index instead of all skills at once."));
+        console.log(ui.dim("  Use arcana load <skill> to load full skill content on demand."));
+    }
+    console.log();
+}

package/dist/commands/info.js

@@ -3,23 +3,27 @@ import { isSkillInstalled, readSkillMeta } from "../utils/fs.js";
 import { getProviders } from "../registry.js";
 import { validateSlug } from "../utils/validate.js";
 export async function infoCommand(skillName, opts) {
+    /* v8 ignore start */
     if (!opts.json) {
         banner();
     }
+    /* v8 ignore stop */
     try {
         validateSlug(skillName, "skill name");
     }
     catch (err) {
         if (opts.json) {
             console.log(JSON.stringify({ error: err instanceof Error ? err.message : "Invalid skill name" }));
+            process.exit(1);
         }
-        else {
-            console.log(ui.error(`  ${err instanceof Error ? err.message : "Invalid skill name"}`));
-            console.log();
-        }
+        /* v8 ignore start */
+        console.log(ui.error(`  ${err instanceof Error ? err.message : "Invalid skill name"}`));
+        console.log();
         process.exit(1);
+        /* v8 ignore stop */
     }
     const providers = getProviders(opts.provider);
+    /* v8 ignore next */
     const s = opts.json ? noopSpinner() : spinner(`Looking up ${ui.bold(skillName)}...`);
     s.start();
     try {
@@ -48,6 +52,7 @@ export async function infoCommand(skillName, opts) {
                     }));
                     return;
                 }
+                /* v8 ignore start */
                 console.log(ui.bold(`  ${skill.name}`) + ui.dim(` v${skill.version}`));
                 if (installed) {
                     const meta = readSkillMeta(skillName);
@@ -86,6 +91,7 @@ export async function infoCommand(skillName, opts) {
                 console.log(ui.dim(`  Install: `) + ui.cyan(`arcana install ${skill.name}`));
                 console.log();
                 return;
+                /* v8 ignore stop */
             }
         }
     }
@@ -107,6 +113,7 @@ export async function infoCommand(skillName, opts) {
                 }));
                 return;
             }
+            /* v8 ignore start */
             console.log(ui.warn("  Showing cached data (offline)"));
             console.log();
             console.log(ui.bold(`  ${skillName}`) + ui.dim(` v${meta?.version ?? "unknown"}`));
@@ -119,21 +126,25 @@ export async function infoCommand(skillName, opts) {
             console.log(ui.dim(`  Source: ${meta?.source ?? "local"}`));
             console.log();
             return;
+            /* v8 ignore stop */
         }
         if (opts.json) {
             console.log(JSON.stringify({ error: err instanceof Error ? err.message : "Lookup failed" }));
             process.exit(1);
         }
+        /* v8 ignore start */
         s.fail("Lookup failed due to a network or provider error.");
         printErrorWithHint(err, true);
         process.exit(1);
+        /* v8 ignore stop */
     }
     if (opts.json) {
         console.log(JSON.stringify({ error: `Skill "${skillName}" not found` }));
+        process.exit(1);
     }
-    else {
-        s.fail(`Skill "${skillName}" not found`);
-        console.log();
-    }
+    /* v8 ignore start */
+    s.fail(`Skill "${skillName}" not found`);
+    console.log();
     process.exit(1);
+    /* v8 ignore stop */
 }

package/dist/commands/init.d.ts

@@ -1,9 +1,12 @@
+type ToolName = "claude" | "cursor" | "codex" | "gemini" | "antigravity" | "windsurf" | "aider";
 interface ProjectInfo {
     name: string;
     type: string;
     lang: string;
 }
 export declare function detectProject(cwd: string): ProjectInfo;
+/** Detect which AI tools are already configured in this project. */
+export declare function detectInstalledTools(cwd: string): ToolName[];
 export declare const SKILL_SUGGESTIONS: Record<string, string[]>;
 export declare const SKILL_SUGGESTIONS_DEFAULT: string[];
 export declare function initCommand(opts: {

package/dist/commands/init.js

@@ -8,6 +8,26 @@ export function detectProject(cwd) {
     const ctx = detectProjectContext(cwd);
     return { name: ctx.name, type: ctx.type, lang: ctx.lang };
 }
+/** Detect which AI tools are already configured in this project. */
+export function detectInstalledTools(cwd) {
+    const tools = [];
+    if (existsSync(join(cwd, "CLAUDE.md")))
+        tools.push("claude");
+    if (existsSync(join(cwd, ".cursor")))
+        tools.push("cursor");
+    if (existsSync(join(cwd, "AGENTS.md")))
+        tools.push("codex");
+    if (existsSync(join(cwd, "GEMINI.md")))
+        tools.push("gemini");
+    if (existsSync(join(cwd, ".windsurfrules")))
+        tools.push("windsurf");
+    if (existsSync(join(cwd, "AGENT.md")))
+        tools.push("antigravity");
+    if (existsSync(join(cwd, ".aider.conf.yml")))
+        tools.push("aider");
+    return tools;
+}
+/* v8 ignore start -- template functions used only in interactive initCommand */
 function claudeTemplate(proj) {
     return `# CLAUDE.md - ${proj.name}
 
@@ -15,6 +35,12 @@ function claudeTemplate(proj) {
 - **Type:** ${proj.type}
 - **Language:** ${proj.lang}
 
+## Skills
+Active skills curated at ~/.agents/skills/_active.md (budget-aware, project-specific).
+Full index at ~/.agents/skills/_index.md.
+Run \`arcana curate\` to refresh after project changes.
+Run \`arcana load <skill>\` for additional skills on demand.
+
 ## Coding Preferences
 - Follow existing patterns in the codebase
 - Handle errors explicitly
@@ -51,6 +77,11 @@ function codexTemplate(proj) {
 ## Project
 Type: ${proj.type} | Language: ${proj.lang}
 
+## Skills
+Active skills curated at ~/.agents/skills/_active.md (budget-aware, project-specific).
+Full index at ~/.agents/skills/_index.md.
+Run \`arcana curate\` to refresh. Run \`arcana load <skill>\` for on-demand loading.
+
 ## Sandbox
 Codex runs in a sandboxed environment with no network access.
 All dependencies must be pre-installed before the session.
@@ -132,6 +163,7 @@ const TOOL_FILES = {
     windsurf: { path: ".windsurfrules", template: windsurfTemplate, label: "Windsurf" },
     aider: { path: ".aider.conf.yml", template: aiderTemplate, label: "Aider" },
 };
+/* v8 ignore stop */
 export const SKILL_SUGGESTIONS = {
     Go: ["golang-pro", "go-linter-configuration", "testing-strategy", "security-review"],
     Rust: ["rust-best-practices", "testing-strategy", "security-review"],
@@ -146,6 +178,7 @@ export const SKILL_SUGGESTIONS_DEFAULT = [
     "codebase-dissection",
     "testing-strategy",
 ];
+/* v8 ignore start */
 export async function initCommand(opts) {
     console.log(renderBanner());
     console.log();
@@ -251,5 +284,43 @@ export async function initCommand(opts) {
     const suggestions = SKILL_SUGGESTIONS[proj.type] || SKILL_SUGGESTIONS_DEFAULT;
     const skillList = suggestions.map((s) => `arcana install ${s}`).join("\n");
     p.note(skillList, "Recommended skills");
+    // Offer context curation
+    const doCurate = await p.confirm({
+        message: "Run context curation? (auto-selects project-relevant skills within token budget)",
+        initialValue: true,
+    });
+    if (!p.isCancel(doCurate) && doCurate) {
+        try {
+            const { regenerateActive } = await import("./curate.js");
+            const result = regenerateActive();
+            p.log.success(`Curated ${result.selected.length} skills (${result.totalTokens.toLocaleString()} tokens)`);
+        }
+        catch {
+            p.log.info("No skills installed yet. Run curate after installing skills.");
+        }
+    }
+    // Offer MCP server setup
+    const doMcp = await p.confirm({
+        message: "Set up MCP servers? (Context7 for live docs, etc.)",
+        initialValue: false,
+    });
+    if (!p.isCancel(doMcp) && doMcp) {
+        try {
+            const { installMcpServer } = await import("../mcp/install.js");
+            const result = installMcpServer("context7", "claude", cwd);
+            if (result.installed) {
+                p.log.success("Context7 MCP configured");
+            }
+        }
+        catch (err) {
+            p.log.warn(`MCP setup: ${err instanceof Error ? err.message : "failed"}`);
+        }
+    }
+    // Show detected tools
+    const detected = detectInstalledTools(cwd);
+    if (detected.length > 0) {
+        p.log.info(`Detected AI tools: ${detected.join(", ")}`);
+    }
     p.outro(`Next: ${chalk.cyan("arcana install <skill>")} or ${chalk.cyan("arcana install --all")}`);
 }
+/* v8 ignore stop */

package/dist/commands/install.js

@@ -11,6 +11,7 @@ export async function installCommand(skillNames, opts) {
     if (opts.json) {
         return installJson(skillNames, opts);
     }
+    /* v8 ignore start */
     console.log(renderBanner());
     console.log();
     if (skillNames.length === 0 && !opts.all) {
@@ -220,6 +221,7 @@ async function installAllInteractive(providers, dryRun, force, noCheck) {
     if (failed.length > 0)
         process.exit(1);
 }
+/* v8 ignore stop */
 async function installJson(skillNames, opts) {
     if (skillNames.length === 0 && !opts.all) {
         console.log(JSON.stringify({ installed: [], skipped: [], failed: [], error: "No skill specified" }));

package/dist/commands/list.js

@@ -5,6 +5,7 @@ import { isSkillInstalled, getInstallDir, readSkillMeta } from "../utils/fs.js";
 import { getProviders } from "../registry.js";
 const DESC_TRUNCATE_LENGTH = 80;
 export async function listCommand(opts) {
+    /* v8 ignore next */
     if (!opts.json)
         banner();
     if (opts.installed) {
@@ -16,6 +17,7 @@ export async function listCommand(opts) {
         for (const provider of providers)
             provider.clearCache();
     }
+    /* v8 ignore next */
     const s = opts.json ? noopSpinner() : spinner("Fetching skills...");
     s.start();
     try {
@@ -39,6 +41,7 @@ export async function listCommand(opts) {
             console.log(JSON.stringify({ skills }, null, 2));
             return;
         }
+        /* v8 ignore start */
         if (skills.length === 0) {
             console.log(ui.dim("  No skills found."));
         }
@@ -57,15 +60,18 @@ export async function listCommand(opts) {
             table(rows);
         }
         console.log();
+        /* v8 ignore stop */
     }
     catch (err) {
         if (opts.json) {
             console.log(JSON.stringify({ error: err instanceof Error ? err.message : "Failed to fetch skills" }));
             process.exit(1);
         }
+        /* v8 ignore start */
         s.fail("Failed to fetch skills");
         printErrorWithHint(err, true);
         process.exit(1);
+        /* v8 ignore stop */
     }
 }
 function listInstalled(json) {
@@ -86,6 +92,7 @@ function listInstalled(json) {
         console.log(JSON.stringify({ skills }, null, 2));
         return;
     }
+    /* v8 ignore start */
     if (dirs.length === 0) {
         console.log(ui.dim("  No skills installed."));
         console.log();
@@ -105,4 +112,5 @@ function listInstalled(json) {
     console.log();
     table(rows);
     console.log();
+    /* v8 ignore stop */
 }

package/dist/commands/load.d.ts

@@ -0,0 +1,10 @@
+/** Read full content of a skill (SKILL.md + references/ + rules/). */
+export declare function readSkillContent(skillName: string): {
+    content: string;
+    files: number;
+    bytes: number;
+} | null;
+export declare function loadCommand(skillNames: string[], opts: {
+    json?: boolean;
+    append?: boolean;
+}): Promise<void>;

package/dist/commands/load.js

@@ -0,0 +1,130 @@
+import { existsSync, readdirSync, readFileSync, statSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getInstallDir } from "../utils/fs.js";
+import { atomicWriteSync } from "../utils/atomic.js";
+import { LOADED_FILENAME } from "../constants.js";
+import { ui, banner } from "../utils/ui.js";
+import { recordLoad } from "../utils/usage.js";
+/** Read full content of a skill (SKILL.md + references/ + rules/). */
+export function readSkillContent(skillName) {
+    const installDir = getInstallDir();
+    const skillDir = join(installDir, skillName);
+    if (!existsSync(skillDir))
+        return null;
+    const skillMd = join(skillDir, "SKILL.md");
+    if (!existsSync(skillMd))
+        return null;
+    const parts = [];
+    let totalBytes = 0;
+    let fileCount = 0;
+    // Main SKILL.md
+    const mainContent = readFileSync(skillMd, "utf-8");
+    parts.push(mainContent);
+    totalBytes += mainContent.length;
+    fileCount++;
+    // References directory (if exists)
+    const refsDir = join(skillDir, "references");
+    if (existsSync(refsDir)) {
+        try {
+            for (const ref of readdirSync(refsDir).sort()) {
+                const refPath = join(refsDir, ref);
+                if (!statSync(refPath).isFile())
+                    continue;
+                const refContent = readFileSync(refPath, "utf-8");
+                parts.push(`\n---\n\n## Reference: ${ref}\n\n${refContent}`);
+                totalBytes += refContent.length;
+                fileCount++;
+            }
+        }
+        catch {
+            /* skip unreadable refs */
+        }
+    }
+    // Rules directory (if exists)
+    const rulesDir = join(skillDir, "rules");
+    if (existsSync(rulesDir)) {
+        try {
+            for (const rule of readdirSync(rulesDir).sort()) {
+                const rulePath = join(rulesDir, rule);
+                if (!statSync(rulePath).isFile())
+                    continue;
+                const ruleContent = readFileSync(rulePath, "utf-8");
+                parts.push(`\n---\n\n## Rule: ${rule}\n\n${ruleContent}`);
+                totalBytes += ruleContent.length;
+                fileCount++;
+            }
+        }
+        catch {
+            /* skip unreadable rules */
+        }
+    }
+    return { content: parts.join("\n"), files: fileCount, bytes: totalBytes };
+}
+export async function loadCommand(skillNames, opts) {
+    if (skillNames.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "Specify one or more skill names" }));
+        }
+        else {
+            console.error("Specify one or more skill names.");
+            console.error("Usage: arcana load <skill> [skill2 ...]");
+            console.error("       arcana load golang-pro typescript --append");
+        }
+        process.exit(1);
+    }
+    const results = [];
+    const loadedParts = [];
+    for (const name of skillNames) {
+        const result = readSkillContent(name);
+        if (!result) {
+            results.push({ name, files: 0, bytes: 0, error: `Skill "${name}" not found` });
+            continue;
+        }
+        results.push({ name, files: result.files, bytes: result.bytes });
+        loadedParts.push(result.content);
+        try {
+            recordLoad(name);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            loaded: results.filter((r) => !r.error).map((r) => ({ name: r.name, files: r.files, bytes: r.bytes })),
+            failed: results.filter((r) => r.error).map((r) => ({ name: r.name, error: r.error })),
+        }));
+        return;
+    }
+    if (opts.append) {
+        // Write aggregated content to _loaded.md
+        const installDir = getInstallDir();
+        mkdirSync(installDir, { recursive: true });
+        const loadedPath = join(installDir, LOADED_FILENAME);
+        const content = loadedParts.join("\n\n---\n\n");
+        atomicWriteSync(loadedPath, content, 0o644);
+        banner();
+        console.log(ui.bold("  Load Skills\n"));
+        for (const r of results) {
+            if (r.error) {
+                console.log(`  ${ui.warn("[!!]")} ${r.name}: ${r.error}`);
+            }
+            else {
+                console.log(`  ${ui.success("[OK]")} ${r.name} (${r.files} files, ${(r.bytes / 1024).toFixed(1)} KB)`);
+            }
+        }
+        console.log();
+        console.log(ui.dim(`  Written to: ${loadedPath}`));
+        console.log();
+    }
+    else {
+        // Print to stdout for piping
+        for (const r of results) {
+            if (r.error) {
+                console.error(`Error: ${r.error}`);
+                continue;
+            }
+        }
+        process.stdout.write(loadedParts.join("\n\n---\n\n"));
+    }
+}