@sporesec/arcana 2.3.1 → 3.0.0

package/dist/commands/import-cmd.js

@@ -0,0 +1,131 @@
+import { readFileSync, existsSync } from "node:fs";
+import { getProvider } from "../registry.js";
+import { installSkill, writeSkillMeta } from "../utils/fs.js";
+import { loadConfig } from "../utils/config.js";
+import { updateLockEntry } from "../utils/integrity.js";
+import { validateSlug } from "../utils/validate.js";
+function parseManifest(raw) {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.skills)) {
+        throw new Error("Invalid manifest: expected object with 'skills' array");
+    }
+    const obj = parsed;
+    const skills = obj.skills.map((entry, i) => {
+        if (typeof entry !== "object" || entry === null) {
+            throw new Error(`Invalid manifest entry at index ${i}`);
+        }
+        const e = entry;
+        if (typeof e.name !== "string" || e.name.length === 0) {
+            throw new Error(`Invalid manifest entry at index ${i}: missing name`);
+        }
+        return {
+            name: e.name,
+            version: typeof e.version === "string" ? e.version : undefined,
+            source: typeof e.source === "string" ? e.source : undefined,
+            description: typeof e.description === "string" ? e.description : undefined,
+        };
+    });
+    return { skills };
+}
+export async function importCommand(file, opts) {
+    if (!existsSync(file)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: `File not found: ${file}` }));
+        }
+        else {
+            console.error(`Error: File not found: ${file}`);
+        }
+        process.exit(1);
+    }
+    let manifest;
+    try {
+        const raw = readFileSync(file, "utf-8");
+        manifest = parseManifest(raw);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to parse manifest";
+        if (opts.json) {
+            console.log(JSON.stringify({ error: msg }));
+        }
+        else {
+            console.error(`Error: ${msg}`);
+        }
+        process.exit(1);
+    }
+    if (manifest.skills.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ installed: [], skipped: [], failed: [], message: "No skills in manifest" }));
+        }
+        else {
+            console.log("No skills found in manifest.");
+        }
+        return;
+    }
+    const config = loadConfig();
+    const installed = [];
+    const skipped = [];
+    const failed = [];
+    const errors = {};
+    for (const entry of manifest.skills) {
+        // Validate skill name
+        try {
+            validateSlug(entry.name, "skill name");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Invalid skill name";
+            failed.push(entry.name);
+            errors[entry.name] = msg;
+            if (!opts.json) {
+                console.error(`Skipping ${entry.name}: ${msg}`);
+            }
+            continue;
+        }
+        // Check if already installed (skip unless --force)
+        const { isSkillInstalled } = await import("../utils/fs.js");
+        if (isSkillInstalled(entry.name) && !opts.force) {
+            skipped.push(entry.name);
+            continue;
+        }
+        // Fetch and install
+        try {
+            const providerName = entry.source ?? config.defaultProvider;
+            const provider = getProvider(providerName);
+            const files = await provider.fetch(entry.name);
+            installSkill(entry.name, files);
+            const remote = await provider.info(entry.name);
+            const version = remote?.version ?? entry.version ?? "0.0.0";
+            writeSkillMeta(entry.name, {
+                version,
+                installedAt: new Date().toISOString(),
+                source: provider.name,
+                description: remote?.description ?? entry.description,
+                fileCount: files.length,
+                sizeBytes: files.reduce((s, f) => s + f.content.length, 0),
+            });
+            updateLockEntry(entry.name, version, provider.name, files);
+            installed.push(entry.name);
+            if (!opts.json) {
+                console.log(`Installed ${entry.name}`);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "unknown error";
+            failed.push(entry.name);
+            errors[entry.name] = msg;
+            if (!opts.json) {
+                console.error(`Failed to install ${entry.name}: ${msg}`);
+            }
+        }
+    }
+    if (opts.json) {
+        const result = { installed, skipped, failed };
+        if (Object.keys(errors).length > 0)
+            result.errors = errors;
+        console.log(JSON.stringify(result));
+    }
+    else {
+        console.log(`Import complete: ${installed.length} installed, ${skipped.length} skipped, ${failed.length} failed`);
+    }
+    if (failed.length > 0)
+        process.exit(1);
+}

package/dist/commands/info.d.ts

@@ -2,4 +2,3 @@ export declare function infoCommand(skillName: string, opts: {
     provider?: string;
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=info.d.ts.map

package/dist/commands/info.js

@@ -39,7 +39,12 @@ export async function infoCommand(skillName, opts) {
                             installedVersion: meta?.version,
                             source: skill.source,
                             repo: skill.repo,
-                        }
+                            tags: skill.tags,
+                            verified: skill.verified,
+                            author: skill.author,
+                            companions: skill.companions,
+                            conflicts: skill.conflicts,
+                        },
                     }));
                     return;
                 }
@@ -47,11 +52,32 @@ export async function infoCommand(skillName, opts) {
                 if (installed) {
                     const meta = readSkillMeta(skillName);
                     const localVersion = meta?.version ?? "unknown";
-                    console.log("  " + ui.success("Installed") + (localVersion !== skill.version ? ui.warn(` (local: v${localVersion})`) : ""));
+                    console.log("  " +
+                        ui.success("Installed") +
+                        (localVersion !== skill.version ? ui.warn(` (local: v${localVersion})`) : ""));
                 }
                 console.log();
                 console.log("  " + skill.description);
                 console.log();
+                if (skill.verified) {
+                    console.log("  " + ui.success("[Verified]") + " Official skill");
+                }
+                else {
+                    console.log(ui.dim("  Community skill"));
+                }
+                if (skill.author) {
+                    console.log(ui.dim(`  Author: ${skill.author}`));
+                }
+                if (skill.tags && skill.tags.length > 0) {
+                    console.log(ui.dim(`  Tags:   ${skill.tags.join(", ")}`));
+                }
+                if (skill.companions && skill.companions.length > 0) {
+                    console.log(ui.dim(`  Works with: ${skill.companions.join(", ")}`));
+                }
+                if (skill.conflicts && skill.conflicts.length > 0) {
+                    console.log(ui.warn(`  Conflicts: ${skill.conflicts.join(", ")}`));
+                }
+                console.log();
                 console.log(ui.dim(`  Source: ${skill.source}`));
                 if (skill.repo) {
                     console.log(ui.dim(`  Repo:   ${skill.repo}`));
@@ -77,7 +103,7 @@ export async function infoCommand(skillName, opts) {
                         installed: true,
                         source: meta?.source ?? "local",
                         offline: true,
-                    }
+                    },
                 }));
                 return;
             }
@@ -111,4 +137,3 @@ export async function infoCommand(skillName, opts) {
     }
     process.exit(1);
 }
-//# sourceMappingURL=info.js.map

package/dist/commands/init.d.ts

@@ -10,4 +10,3 @@ export declare function initCommand(opts: {
     tool?: string;
 }): Promise<void>;
 export {};
-//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -1,139 +1,122 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join, basename, dirname } from "node:path";
+import { join, dirname } from "node:path";
 import * as p from "@clack/prompts";
 import chalk from "chalk";
 import { renderBanner } from "../utils/help.js";
+import { detectProjectContext } from "../utils/project-context.js";
 export function detectProject(cwd) {
-    const name = basename(cwd);
-    if (existsSync(join(cwd, "go.mod")))
-        return { name, type: "Go", lang: "go" };
-    if (existsSync(join(cwd, "Cargo.toml")))
-        return { name, type: "Rust", lang: "rust" };
-    if (existsSync(join(cwd, "requirements.txt")) || existsSync(join(cwd, "pyproject.toml")))
-        return { name, type: "Python", lang: "python" };
-    if (existsSync(join(cwd, "package.json"))) {
-        try {
-            const raw = readFileSync(join(cwd, "package.json"), "utf-8");
-            const pkg = JSON.parse(raw);
-            if (pkg.dependencies?.next || pkg.devDependencies?.next)
-                return { name, type: "Next.js", lang: "typescript" };
-            if (pkg.dependencies?.react || pkg.devDependencies?.react)
-                return { name, type: "React", lang: "typescript" };
-        }
-        catch { /* ignore */ }
-        return { name, type: "Node.js", lang: "typescript" };
-    }
-    return { name, type: "Unknown", lang: "general" };
+    const ctx = detectProjectContext(cwd);
+    return { name: ctx.name, type: ctx.type, lang: ctx.lang };
 }
 function claudeTemplate(proj) {
-    return `# CLAUDE.md - ${proj.name}
-
-## Project
-- **Type:** ${proj.type}
-- **Language:** ${proj.lang}
-
-## Coding Preferences
-- Follow existing patterns in the codebase
-- Handle errors explicitly
-- Use meaningful variable names, no abbreviations
-
-## Build & Test
-<!-- Add build/test commands so Claude can verify changes -->
-<!-- Example: npm test, go test ./..., pytest -->
-
-## Project Structure
-<!-- Describe your project structure here -->
+    return `# CLAUDE.md - ${proj.name}
+
+## Project
+- **Type:** ${proj.type}
+- **Language:** ${proj.lang}
+
+## Coding Preferences
+- Follow existing patterns in the codebase
+- Handle errors explicitly
+- Use meaningful variable names, no abbreviations
+
+## Build & Test
+<!-- Add build/test commands so Claude can verify changes -->
+<!-- Example: npm test, go test ./..., pytest -->
+
+## Project Structure
+<!-- Describe your project structure here -->
 `;
 }
 function cursorTemplate(proj) {
-    return `---
-description: Project conventions for ${proj.name}
-globs:
----
-
-# ${proj.name} (${proj.type})
-
-## Language
-${proj.lang}
-
-## Coding Standards
-- Follow existing patterns in the codebase
-- Handle errors explicitly
-- Use meaningful variable names
+    return `---
+description: Project conventions for ${proj.name}
+globs:
+---
+
+# ${proj.name} (${proj.type})
+
+## Language
+${proj.lang}
+
+## Coding Standards
+- Follow existing patterns in the codebase
+- Handle errors explicitly
+- Use meaningful variable names
 `;
 }
 function codexTemplate(proj) {
-    return `# AGENTS.md - ${proj.name}
-
-## Project
-Type: ${proj.type} | Language: ${proj.lang}
-
-## Sandbox
-Codex runs in a sandboxed environment with no network access.
-All dependencies must be pre-installed before the session.
-
-## Guidelines
-- Follow existing patterns in the codebase
-- Handle errors explicitly
-- Use meaningful variable names
+    return `# AGENTS.md - ${proj.name}
+
+## Project
+Type: ${proj.type} | Language: ${proj.lang}
+
+## Sandbox
+Codex runs in a sandboxed environment with no network access.
+All dependencies must be pre-installed before the session.
+
+## Guidelines
+- Follow existing patterns in the codebase
+- Handle errors explicitly
+- Use meaningful variable names
 `;
 }
 function geminiTemplate(proj) {
-    return `# GEMINI.md - ${proj.name}
-
-## Project Context
-This is a ${proj.type} project using ${proj.lang}.
-
-## Project Files
-<!-- List key files and directories so Gemini can navigate the codebase -->
-<!-- Example: src/ - main source, tests/ - test files -->
-
-## Instructions
-- Follow existing patterns in the codebase
-- Handle errors explicitly
-- Use meaningful variable names
+    return `# GEMINI.md - ${proj.name}
+
+## Project Context
+This is a ${proj.type} project using ${proj.lang}.
+
+## Project Files
+<!-- List key files and directories so Gemini can navigate the codebase -->
+<!-- Example: src/ - main source, tests/ - test files -->
+
+## Instructions
+- Follow existing patterns in the codebase
+- Handle errors explicitly
+- Use meaningful variable names
 `;
 }
 function antigravityTemplate(proj) {
-    return `# Antigravity - ${proj.name}
-
-## Project Context
-This is a ${proj.type} project using ${proj.lang}.
-Antigravity workspace: \`.agent/\` (rules, workflows, skills)
-
-## Project Files
-<!-- List key files and directories so the agent can navigate the codebase -->
-<!-- Example: src/ - main source, tests/ - test files -->
-
-## Instructions
-- Follow existing patterns in the codebase
-- Handle errors explicitly
-- Use meaningful variable names
+    return `# Antigravity - ${proj.name}
+
+## Project Context
+This is a ${proj.type} project using ${proj.lang}.
+Antigravity workspace: \`.agent/\` (rules, workflows, skills)
+
+## Project Files
+<!-- List key files and directories so the agent can navigate the codebase -->
+<!-- Example: src/ - main source, tests/ - test files -->
+
+## Instructions
+- Follow existing patterns in the codebase
+- Handle errors explicitly
+- Use meaningful variable names
 `;
 }
 function windsurfTemplate(proj) {
-    return `# Windsurf Cascades Rules - ${proj.name}
-
-Project: ${proj.name} (${proj.type})
-Language: ${proj.lang}
-
-## Rules
-- Follow existing patterns in the codebase
-- Handle errors explicitly
-- Use meaningful variable names
-- Always explain changes before applying them
+    return `# Windsurf Cascades Rules - ${proj.name}
+
+Project: ${proj.name} (${proj.type})
+Language: ${proj.lang}
+
+## Rules
+- Follow existing patterns in the codebase
+- Handle errors explicitly
+- Use meaningful variable names
+- Always explain changes before applying them
 `;
 }
 function aiderTemplate(_proj) {
-    return `# Aider Configuration
-model: sonnet
-auto-commits: true
-auto-test: false
-# Add conventions below
-conventions:
-  - Follow existing patterns in the codebase
-  - Write clean, maintainable code
-  - Handle errors explicitly
+    return `# Aider Configuration
+model: sonnet
+auto-commits: true
+auto-test: false
+# Add conventions below
+conventions:
+  - Follow existing patterns in the codebase
+  - Write clean, maintainable code
+  - Handle errors explicitly
 `;
 }
 const TOOL_FILES = {
@@ -150,14 +133,19 @@ const TOOL_FILES = {
     aider: { path: ".aider.conf.yml", template: aiderTemplate, label: "Aider" },
 };
 export const SKILL_SUGGESTIONS = {
-    "Go": ["golang-pro", "go-linter-configuration", "testing-strategy", "security-review"],
-    "Rust": ["rust-best-practices", "testing-strategy", "security-review"],
-    "Python": ["python-best-practices", "testing-strategy", "security-review"],
+    Go: ["golang-pro", "go-linter-configuration", "testing-strategy", "security-review"],
+    Rust: ["rust-best-practices", "testing-strategy", "security-review"],
+    Python: ["python-best-practices", "testing-strategy", "security-review"],
     "Next.js": ["typescript", "typescript-advanced", "frontend-design", "performance-optimization", "security-review"],
-    "React": ["typescript", "frontend-design", "frontend-code-review", "testing-strategy"],
+    React: ["typescript", "frontend-design", "frontend-code-review", "testing-strategy"],
     "Node.js": ["typescript", "npm-package", "testing-strategy", "security-review"],
 };
-export const SKILL_SUGGESTIONS_DEFAULT = ["code-reviewer", "security-review", "codebase-dissection", "testing-strategy"];
+export const SKILL_SUGGESTIONS_DEFAULT = [
+    "code-reviewer",
+    "security-review",
+    "codebase-dissection",
+    "testing-strategy",
+];
 export async function initCommand(opts) {
     console.log(renderBanner());
     console.log();
@@ -208,9 +196,60 @@ export async function initCommand(opts) {
     }
     if (skipped > 0)
         p.log.info(`${skipped} skipped (already exist)`);
+    // Offer to install PreCompact hook for context preservation
+    const globalSettings = join(process.env.HOME || process.env.USERPROFILE || "", ".claude", "settings.json");
+    let hasPreCompactHook = false;
+    if (existsSync(globalSettings)) {
+        try {
+            const settings = JSON.parse(readFileSync(globalSettings, "utf-8"));
+            hasPreCompactHook = Array.isArray(settings?.hooks?.PreCompact) && settings.hooks.PreCompact.length > 0;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    if (!hasPreCompactHook) {
+        const installHook = await p.confirm({
+            message: "Install PreCompact hook? (preserves context before auto-compaction)",
+            initialValue: true,
+        });
+        if (p.isCancel(installHook)) {
+            p.cancel("Cancelled");
+            process.exit(0);
+        }
+        if (installHook) {
+            try {
+                let settings = {};
+                if (existsSync(globalSettings)) {
+                    settings = JSON.parse(readFileSync(globalSettings, "utf-8"));
+                }
+                const hooks = (settings.hooks ?? {});
+                hooks.PreCompact = [
+                    {
+                        matcher: "",
+                        hooks: [
+                            {
+                                type: "command",
+                                command: 'bash -c \'PROJ_DIR="$HOME/.claude/projects"; for d in "$PROJ_DIR"/*/memory; do if [ -d "$d" ]; then echo "## Handover $(date +%Y-%m-%d_%H%M)" >> "$d/HANDOVER.md"; echo "Auto-compaction triggered. Review MEMORY.md for preserved context." >> "$d/HANDOVER.md"; echo "" >> "$d/HANDOVER.md"; fi; done\'',
+                                timeout: 10,
+                            },
+                        ],
+                    },
+                ];
+                settings.hooks = hooks;
+                writeFileSync(globalSettings, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+                p.log.success("Installed PreCompact hook in ~/.claude/settings.json");
+            }
+            catch (err) {
+                p.log.warn(`Could not install hook: ${err instanceof Error ? err.message : "unknown"}`);
+            }
+        }
+    }
+    else {
+        p.log.info("PreCompact hook already installed");
+    }
     const suggestions = SKILL_SUGGESTIONS[proj.type] || SKILL_SUGGESTIONS_DEFAULT;
     const skillList = suggestions.map((s) => `arcana install ${s}`).join("\n");
     p.note(skillList, "Recommended skills");
     p.outro(`Next: ${chalk.cyan("arcana install <skill>")} or ${chalk.cyan("arcana install --all")}`);
 }
-//# sourceMappingURL=init.js.map

package/dist/commands/install.d.ts

@@ -4,5 +4,5 @@ export declare function installCommand(skillNames: string[], opts: {
     force?: boolean;
     dryRun?: boolean;
     json?: boolean;
+    noCheck?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=install.d.ts.map