@sporesec/arcana 2.4.0 → 3.0.1

package/dist/interactive.js

@@ -18,39 +18,74 @@ const AMBER = chalk.hex("#d4943a");
 // ---------------------------------------------------------------------------
 const SKILL_CATEGORIES = {
     "Code Quality & Review": [
-        "code-reviewer", "codebase-dissection", "testing-strategy",
-        "refactoring-patterns", "git-workflow", "pre-production-review",
-        "frontend-code-review", "dependency-audit", "performance-optimization",
+        "code-reviewer",
+        "codebase-dissection",
+        "testing-strategy",
+        "refactoring-patterns",
+        "git-workflow",
+        "pre-production-review",
+        "frontend-code-review",
+        "dependency-audit",
+        "performance-optimization",
     ],
     "Security & Infrastructure": [
-        "security-review", "local-security", "container-security",
-        "docker-kubernetes", "ci-cd-pipelines", "ci-cd-automation",
-        "monitoring-observability", "incident-response",
+        "security-review",
+        "local-security",
+        "container-security",
+        "docker-kubernetes",
+        "ci-cd-pipelines",
+        "ci-cd-automation",
+        "monitoring-observability",
+        "incident-response",
     ],
     "Languages & Frameworks": [
-        "golang-pro", "go-linter-configuration", "typescript", "typescript-advanced",
-        "python-best-practices", "rust-best-practices", "frontend-design",
-        "fullstack-developer", "remotion-best-practices", "npm-package",
+        "golang-pro",
+        "go-linter-configuration",
+        "typescript",
+        "typescript-advanced",
+        "python-best-practices",
+        "rust-best-practices",
+        "frontend-design",
+        "fullstack-developer",
+        "remotion-best-practices",
+        "npm-package",
     ],
     "API, Data & Docs": [
-        "api-design", "api-testing", "programming-architecture",
-        "database-design", "env-config", "cost-optimization",
-        "docx", "xlsx", "doc-generation", "update-docs",
+        "api-design",
+        "api-testing",
+        "programming-architecture",
+        "database-design",
+        "env-config",
+        "cost-optimization",
+        "docx",
+        "xlsx",
+        "doc-generation",
+        "update-docs",
     ],
     "Game Design & Production": [
-        "game-design-theory", "game-engines", "game-programming-languages",
-        "gameplay-mechanics", "level-design", "game-tools-workflows",
-        "game-servers", "networking-servers", "synchronization-algorithms",
-        "monetization-systems", "publishing-platforms", "daw-music",
+        "game-design-theory",
+        "game-engines",
+        "game-programming-languages",
+        "gameplay-mechanics",
+        "level-design",
+        "game-tools-workflows",
+        "game-servers",
+        "networking-servers",
+        "synchronization-algorithms",
+        "monetization-systems",
+        "publishing-platforms",
+        "daw-music",
     ],
     "Graphics, Audio & Performance": [
-        "graphics-rendering", "shader-techniques", "particle-systems",
-        "audio-systems", "asset-optimization", "optimization-performance",
+        "graphics-rendering",
+        "shader-techniques",
+        "particle-systems",
+        "audio-systems",
+        "asset-optimization",
+        "optimization-performance",
         "memory-management",
     ],
-    "Skill Development": [
-        "skill-creation-guide", "skill-creator", "find-skills", "project-migration",
-    ],
+    "Skill Development": ["skill-creation-guide", "skill-creator", "find-skills", "project-migration"],
 };
 // ---------------------------------------------------------------------------
 // Helpers
@@ -68,7 +103,7 @@ function countInstalled() {
     const dir = getInstallDir();
     if (!existsSync(dir))
         return 0;
-    return readdirSync(dir).filter(d => {
+    return readdirSync(dir).filter((d) => {
         try {
             return statSync(join(dir, d)).isDirectory();
         }
@@ -91,16 +126,14 @@ function getRelatedSkills(skillName, limit = 3) {
     const cat = getCategoryFor(skillName);
     if (!cat)
         return [];
-    return (SKILL_CATEGORIES[cat] ?? [])
-        .filter(s => s !== skillName && !isSkillInstalled(s))
-        .slice(0, limit);
+    return (SKILL_CATEGORIES[cat] ?? []).filter((s) => s !== skillName && !isSkillInstalled(s)).slice(0, limit);
 }
 function getInstalledNames() {
     const dir = getInstallDir();
     if (!existsSync(dir))
         return [];
     return readdirSync(dir)
-        .filter(d => {
+        .filter((d) => {
         try {
             return statSync(join(dir, d)).isDirectory();
         }
@@ -110,7 +143,7 @@ function getInstalledNames() {
     })
         .sort();
 }
-function buildMenuOptions(installedCount, availableCount) {
+function buildMenuOptions(installedCount, _availableCount) {
     const isNew = installedCount === 0;
     const options = [];
     if (isNew) {
@@ -211,7 +244,7 @@ function doUninstall(skillName) {
 // Skill Detail View (central action point)
 // ---------------------------------------------------------------------------
 async function skillDetailFlow(skillName, allSkills, providerName) {
-    const info = allSkills.find(s => s.name === skillName);
+    const info = allSkills.find((s) => s.name === skillName);
     const installed = isSkillInstalled(skillName);
     const meta = installed ? readSkillMeta(skillName) : null;
     // Build info block
@@ -277,11 +310,11 @@ async function skillDetailFlow(skillName, allSkills, providerName) {
 // Browse by Category
 // ---------------------------------------------------------------------------
 async function browseByCategory(allSkills, providerName) {
-    const availableNames = new Set(allSkills.map(s => s.name));
+    const availableNames = new Set(allSkills.map((s) => s.name));
     while (true) {
         const categoryOptions = Object.entries(SKILL_CATEGORIES).map(([name, skills]) => {
-            const valid = skills.filter(s => availableNames.has(s));
-            const installedCount = valid.filter(s => isSkillInstalled(s)).length;
+            const valid = skills.filter((s) => availableNames.has(s));
+            const installedCount = valid.filter((s) => isSkillInstalled(s)).length;
             return {
                 value: name,
                 label: name,
@@ -290,10 +323,7 @@ async function browseByCategory(allSkills, providerName) {
         });
         const category = await p.select({
             message: "Browse by category",
-            options: [
-                ...categoryOptions,
-                { value: "__back", label: "Back" },
-            ],
+            options: [...categoryOptions, { value: "__back", label: "Back" }],
         });
         handleCancel(category);
         if (category === "__back")
@@ -302,15 +332,15 @@ async function browseByCategory(allSkills, providerName) {
     }
 }
 async function categorySkillList(categoryName, skillNames, allSkills, providerName) {
-    const availableNames = new Set(allSkills.map(s => s.name));
-    const validSkills = skillNames.filter(s => availableNames.has(s));
+    const availableNames = new Set(allSkills.map((s) => s.name));
+    const validSkills = skillNames.filter((s) => availableNames.has(s));
     if (validSkills.length === 0) {
         p.log.warn("No skills found in this category.");
         return;
     }
     while (true) {
-        const options = validSkills.map(name => {
-            const info = allSkills.find(s => s.name === name);
+        const options = validSkills.map((name) => {
+            const info = allSkills.find((s) => s.name === name);
             const installed = isSkillInstalled(name);
             return {
                 value: name,
@@ -318,7 +348,7 @@ async function categorySkillList(categoryName, skillNames, allSkills, providerNa
                 hint: truncate(info?.description ?? "", 50),
             };
         });
-        const notInstalled = validSkills.filter(s => !isSkillInstalled(s));
+        const notInstalled = validSkills.filter((s) => !isSkillInstalled(s));
         const extraOptions = [];
         if (notInstalled.length > 0) {
             extraOptions.push({
@@ -386,18 +416,14 @@ async function searchFlow(allSkills, providerName) {
 }
 async function searchResultsPicker(results, allSkills, providerName) {
     while (true) {
-        const options = results.map(skill => ({
+        const options = results.map((skill) => ({
             value: skill.name,
             label: `${skill.name}${isSkillInstalled(skill.name) ? chalk.green(" \u2713") : ""}`,
             hint: truncate(skill.description, 50),
         }));
         const picked = await p.select({
             message: "Pick a skill for details",
-            options: [
-                ...options,
-                { value: "__search", label: "Search again" },
-                { value: "__back", label: "Back" },
-            ],
+            options: [...options, { value: "__search", label: "Search again" }, { value: "__back", label: "Back" }],
         });
         handleCancel(picked);
         if (picked === "__search")
@@ -417,7 +443,7 @@ async function quickSetup(allSkills, providerName) {
     const proj = detectProject(process.cwd());
     p.log.step(`Detected: ${chalk.cyan(proj.name)} (${proj.type})`);
     const suggestions = SKILL_SUGGESTIONS[proj.type] ?? SKILL_SUGGESTIONS_DEFAULT;
-    const availableNames = new Set(allSkills.map(s => s.name));
+    const availableNames = new Set(allSkills.map((s) => s.name));
     const validSuggestions = suggestions.filter((s) => availableNames.has(s));
     if (validSuggestions.length === 0) {
         p.log.info("No specific recommendations for this project type.");
@@ -467,17 +493,17 @@ async function manageInstalled(allSkills, providerName) {
         const groups = [];
         const categorized = new Set();
         for (const [cat, catSkills] of Object.entries(SKILL_CATEGORIES)) {
-            const installed = catSkills.filter(s => names.includes(s));
+            const installed = catSkills.filter((s) => names.includes(s));
             if (installed.length > 0) {
                 groups.push({ cat, skills: installed });
-                installed.forEach(s => categorized.add(s));
+                installed.forEach((s) => categorized.add(s));
             }
         }
-        const uncategorized = names.filter(s => !categorized.has(s));
+        const uncategorized = names.filter((s) => !categorized.has(s));
         if (uncategorized.length > 0) {
             groups.push({ cat: "Other", skills: uncategorized });
         }
-        const options = groups.map(g => ({
+        const options = groups.map((g) => ({
             value: g.cat,
             label: g.cat,
             hint: `${g.skills.length} installed`,
@@ -502,7 +528,7 @@ async function manageInstalled(allSkills, providerName) {
             await bulkUninstall(names);
             continue;
         }
-        const group = groups.find(g => g.cat === picked);
+        const group = groups.find((g) => g.cat === picked);
         if (group) {
             await installedCategoryList(group.cat, group.skills, allSkills, providerName);
         }
@@ -510,12 +536,12 @@ async function manageInstalled(allSkills, providerName) {
 }
 async function installedCategoryList(categoryName, installedNames, allSkills, providerName) {
     while (true) {
-        const stillInstalled = installedNames.filter(s => isSkillInstalled(s));
+        const stillInstalled = installedNames.filter((s) => isSkillInstalled(s));
         if (stillInstalled.length === 0) {
             p.log.info("No skills remaining in this category.");
             return;
         }
-        const options = stillInstalled.map(name => {
+        const options = stillInstalled.map((name) => {
             const meta = readSkillMeta(name);
             const ver = meta ? `v${meta.version}` : "";
             const date = meta?.installedAt ? new Date(meta.installedAt).toLocaleDateString() : "";
@@ -540,7 +566,7 @@ async function installedCategoryList(categoryName, installedNames, allSkills, pr
 async function bulkUninstall(installedNames) {
     const selected = await p.multiselect({
         message: "Select skills to uninstall",
-        options: installedNames.map(name => ({ value: name, label: name })),
+        options: installedNames.map((name) => ({ value: name, label: name })),
         required: false,
         maxItems: 15,
     });
@@ -583,7 +609,7 @@ async function updateAll(providerName) {
             p.log.error(ui.dim(err.message));
         return;
     }
-    const remoteMap = new Map(remoteSkills.map(rs => [rs.name, rs]));
+    const remoteMap = new Map(remoteSkills.map((rs) => [rs.name, rs]));
     const updates = [];
     for (const name of installed) {
         const remote = remoteMap.get(name);
@@ -642,15 +668,13 @@ async function checkHealth() {
     const checks = runDoctorChecks();
     p.log.step(chalk.bold("Environment Health Check"));
     for (const check of checks) {
-        const icon = check.status === "pass" ? chalk.green("OK")
-            : check.status === "warn" ? chalk.yellow("!!")
-                : chalk.red("XX");
+        const icon = check.status === "pass" ? chalk.green("OK") : check.status === "warn" ? chalk.yellow("!!") : chalk.red("XX");
         p.log.info(`${icon}  ${chalk.bold(check.name)}: ${check.message}`);
         if (check.fix)
             p.log.info(chalk.dim(`    Fix: ${check.fix}`));
     }
-    const fails = checks.filter(c => c.status === "fail").length;
-    const warns = checks.filter(c => c.status === "warn").length;
+    const fails = checks.filter((c) => c.status === "fail").length;
+    const warns = checks.filter((c) => c.status === "warn").length;
     if (fails > 0) {
         p.log.error(`${fails} issue${fails > 1 ? "s" : ""} found`);
     }
@@ -662,10 +686,10 @@ async function checkHealth() {
         return;
     }
     // Offer fixes once - no loop. User can re-enter health check to verify.
-    const fixChecks = checks.filter(c => c.fix && c.status !== "pass");
+    const fixChecks = checks.filter((c) => c.fix && c.status !== "pass");
     if (fixChecks.length === 0)
         return;
-    const fixOptions = fixChecks.map(c => {
+    const fixOptions = fixChecks.map((c) => {
         const cmd = c.fix.replace(/^Run:\s*/, "");
         return { value: cmd, label: `Run: ${cmd}`, hint: c.name };
     });
@@ -677,7 +701,7 @@ async function checkHealth() {
     if (fixAction !== "__skip") {
         const cmd = fixAction;
         const SAFE_PREFIXES = ["arcana ", "git config "];
-        if (!SAFE_PREFIXES.some(pre => cmd.startsWith(pre))) {
+        if (!SAFE_PREFIXES.some((pre) => cmd.startsWith(pre))) {
             p.log.warn(`Skipped unsafe command: ${cmd}`);
         }
         else {
@@ -724,7 +748,7 @@ export async function showInteractiveMenu(version) {
     const config = loadConfig();
     const providerName = config.defaultProvider;
     // Fetch skill list once for the session
-    let allSkills = [];
+    const allSkills = [];
     let availableCount = 0;
     try {
         const providers = getProviders();
@@ -815,4 +839,3 @@ export async function showInteractiveMenu(version) {
         }
     }
 }
-//# sourceMappingURL=interactive.js.map

package/dist/providers/arcana.d.ts

@@ -2,4 +2,3 @@ import { GitHubProvider } from "./github.js";
 export declare class ArcanaProvider extends GitHubProvider {
     constructor();
 }
-//# sourceMappingURL=arcana.d.ts.map

package/dist/providers/arcana.js

@@ -8,4 +8,3 @@ export class ArcanaProvider extends GitHubProvider {
         });
     }
 }
-//# sourceMappingURL=arcana.js.map

package/dist/providers/base.d.ts

@@ -8,4 +8,3 @@ export declare abstract class Provider {
     clearCache(): void;
     info(skillName: string): Promise<SkillInfo | null>;
 }
-//# sourceMappingURL=base.d.ts.map

package/dist/providers/base.js

@@ -7,4 +7,3 @@ export class Provider {
         return skills.find((s) => s.name === skillName) ?? null;
     }
 }
-//# sourceMappingURL=base.js.map

package/dist/providers/github.d.ts

@@ -22,4 +22,3 @@ export declare class GitHubProvider extends Provider {
     search(query: string): Promise<SkillInfo[]>;
     clearCache(): void;
 }
-//# sourceMappingURL=github.d.ts.map

package/dist/providers/github.js

@@ -81,6 +81,11 @@ export class GitHubProvider extends Provider {
             version: p.version,
             source: this.name,
             repo: `https://github.com/${this.owner}/${this.repo}`,
+            tags: p.tags,
+            conflicts: p.conflicts,
+            companions: p.companions,
+            verified: p.verified,
+            author: p.author,
         }));
         // Warn about malformed entries
         const skipped = data.plugins.length - this.cache.length;
@@ -119,7 +124,7 @@ export class GitHubProvider extends Provider {
                 return { path: relativePath, content };
             }
             catch (err) {
-                throw new Error(`Failed to fetch file "${relativePath}" for skill "${skillName}": ${err instanceof Error ? err.message : String(err)}`);
+                throw new Error(`Failed to fetch file "${relativePath}" for skill "${skillName}": ${err instanceof Error ? err.message : String(err)}`, { cause: err });
             }
         }, 6);
         return results.filter((r) => r !== null);
@@ -128,7 +133,8 @@ export class GitHubProvider extends Provider {
         const all = await this.list();
         const q = query.toLowerCase();
         const exact = all.filter((s) => s.name.toLowerCase().includes(q) ||
-            s.description.toLowerCase().includes(q));
+            s.description.toLowerCase().includes(q) ||
+            s.tags?.some((t) => t.toLowerCase().includes(q)));
         if (exact.length > 0)
             return exact;
         // Fuzzy fallback: match skills where Levenshtein distance to name <= 3
@@ -143,4 +149,3 @@ export class GitHubProvider extends Provider {
         clearCacheFile(this.cacheKey);
     }
 }
-//# sourceMappingURL=github.js.map

package/dist/registry.d.ts

@@ -6,4 +6,3 @@ export declare function parseProviderSlug(input: string): {
 };
 export declare function getProvider(name?: string): Provider;
 export declare function getProviders(name?: string): Provider[];
-//# sourceMappingURL=registry.d.ts.map

package/dist/registry.js

@@ -64,8 +64,5 @@ export function getProviders(name) {
     if (name)
         return [getProvider(name)];
     const config = loadConfig();
-    return config.providers
-        .filter((p) => p.enabled)
-        .map((p) => createProvider(p.name, p.type, p.url));
+    return config.providers.filter((p) => p.enabled).map((p) => createProvider(p.name, p.type, p.url));
 }
-//# sourceMappingURL=registry.js.map

package/dist/types.d.ts

@@ -4,6 +4,11 @@ export interface SkillInfo {
     version: string;
     source: string;
     repo?: string;
+    tags?: string[];
+    conflicts?: string[];
+    companions?: string[];
+    verified?: boolean;
+    author?: string;
 }
 export interface SkillFile {
     path: string;
@@ -26,6 +31,11 @@ export interface MarketplacePlugin {
     source: string;
     description: string;
     version: string;
+    tags?: string[];
+    conflicts?: string[];
+    companions?: string[];
+    verified?: boolean;
+    author?: string;
 }
 export interface ProviderConfig {
     name: string;
@@ -64,4 +74,3 @@ export interface DoctorCheck {
     message: string;
     fix?: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/utils/atomic.d.ts

@@ -1,2 +1 @@
 export declare function atomicWriteSync(filePath: string, content: string, mode?: number): void;
-//# sourceMappingURL=atomic.d.ts.map

package/dist/utils/atomic.js

@@ -13,8 +13,9 @@ export function atomicWriteSync(filePath, content, mode = 0o644) {
         try {
             unlinkSync(tmpPath);
         }
-        catch { /* cleanup best-effort */ }
+        catch {
+            /* cleanup best-effort */
+        }
         throw err;
     }
 }
-//# sourceMappingURL=atomic.js.map

package/dist/utils/cache.d.ts

@@ -1,4 +1,3 @@
 export declare function readCache<T>(key: string, maxAgeMs?: number): T | null;
 export declare function writeCache<T>(key: string, data: T): void;
 export declare function clearCacheFile(key: string): void;
-//# sourceMappingURL=cache.d.ts.map

package/dist/utils/cache.js

@@ -41,7 +41,8 @@ export function clearCacheFile(key) {
         try {
             unlinkSync(file);
         }
-        catch { /* best-effort */ }
+        catch {
+            /* best-effort */
+        }
     }
 }
-//# sourceMappingURL=cache.js.map

package/dist/utils/config.d.ts

@@ -1,6 +1,7 @@
 import type { ArcanaConfig, ProviderConfig } from "../types.js";
+/** Validate config and return warnings for invalid fields. */
+export declare function validateConfig(config: ArcanaConfig): string[];
 export declare function loadConfig(): ArcanaConfig;
 export declare function saveConfig(config: ArcanaConfig): void;
 export declare function addProvider(provider: ProviderConfig): void;
 export declare function removeProvider(name: string): boolean;
-//# sourceMappingURL=config.d.ts.map

package/dist/utils/config.js

@@ -4,6 +4,8 @@ import { homedir } from "node:os";
 import { ui } from "./ui.js";
 import { atomicWriteSync } from "./atomic.js";
 const CONFIG_PATH = join(homedir(), ".arcana", "config.json");
+/** Matches owner/repo slug format (e.g. "medy-gribkov/arcana") */
+const SLUG_RE = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
 const DEFAULT_CONFIG = {
     defaultProvider: "arcana",
     installDir: join(homedir(), ".agents", "skills"),
@@ -17,7 +19,27 @@ const DEFAULT_CONFIG = {
     ],
 };
 function cloneConfig(config) {
-    return { ...config, providers: config.providers.map(p => ({ ...p })) };
+    return { ...config, providers: config.providers.map((p) => ({ ...p })) };
+}
+/** Validate config and return warnings for invalid fields. */
+export function validateConfig(config) {
+    const warnings = [];
+    // Validate providers have valid owner/repo slugs
+    for (const p of config.providers) {
+        if (p.type === "github" && !SLUG_RE.test(p.url)) {
+            warnings.push(`Provider "${p.name}" has invalid URL "${p.url}". Expected owner/repo format.`);
+        }
+    }
+    // Validate installDir is absolute
+    if (!isAbsolute(config.installDir)) {
+        warnings.push(`installDir "${config.installDir}" is not an absolute path.`);
+    }
+    // Validate defaultProvider matches a configured provider or valid slug
+    const providerNames = config.providers.map((p) => p.name);
+    if (!providerNames.includes(config.defaultProvider) && !SLUG_RE.test(config.defaultProvider)) {
+        warnings.push(`defaultProvider "${config.defaultProvider}" doesn't match any configured provider and isn't a valid slug.`);
+    }
+    return warnings;
 }
 export function loadConfig() {
     if (!existsSync(CONFIG_PATH)) {
@@ -29,7 +51,7 @@ export function loadConfig() {
         const config = {
             ...DEFAULT_CONFIG,
             ...loaded,
-            providers: loaded.providers ?? DEFAULT_CONFIG.providers.map(p => ({ ...p })),
+            providers: loaded.providers ?? DEFAULT_CONFIG.providers.map((p) => ({ ...p })),
         };
         return applyEnvOverrides(config);
     }
@@ -51,11 +73,15 @@ function applyEnvOverrides(base) {
     }
     const envProvider = process.env.ARCANA_DEFAULT_PROVIDER;
     if (envProvider) {
-        if (envProvider.trim().length === 0) {
+        const trimmed = envProvider.trim();
+        if (trimmed.length === 0) {
             console.error(ui.warn("  Warning: ARCANA_DEFAULT_PROVIDER is empty. Ignoring."));
         }
+        else if (!SLUG_RE.test(trimmed) && !config.providers.some((p) => p.name === trimmed)) {
+            console.error(ui.warn(`  Warning: ARCANA_DEFAULT_PROVIDER "${trimmed}" is not a valid slug. Ignoring.`));
+        }
         else {
-            config.defaultProvider = envProvider.trim();
+            config.defaultProvider = trimmed;
         }
     }
     return config;
@@ -87,4 +113,3 @@ export function removeProvider(name) {
     saveConfig(config);
     return true;
 }
-//# sourceMappingURL=config.js.map

package/dist/utils/conflict-check.d.ts

@@ -0,0 +1,8 @@
+import type { SkillInfo } from "../types.js";
+import type { ProjectContext } from "./project-context.js";
+export interface ConflictWarning {
+    type: "rule-overlap" | "skill-conflict" | "preference-clash";
+    message: string;
+    severity: "warn" | "block";
+}
+export declare function checkConflicts(skillName: string, skillInfo: SkillInfo | null, skillContent: string | null, context: ProjectContext): ConflictWarning[];

package/dist/utils/conflict-check.js

@@ -0,0 +1,72 @@
+/** Known opposing preference pairs. If a skill promotes one, and CLAUDE.md has the other, warn. */
+const OPPOSING_PAIRS = [
+    ["callbacks", "async/await"],
+    ["any", "strict typing"],
+    ["abbreviations", "meaningful names"],
+    ["classes", "functional"],
+    ["oop", "functional programming"],
+    ["semicolons", "no semicolons"],
+    ["tabs", "spaces"],
+];
+export function checkConflicts(skillName, skillInfo, skillContent, context) {
+    const warnings = [];
+    // 1. Explicit skill-level conflicts from marketplace metadata
+    if (skillInfo?.conflicts && skillInfo.conflicts.length > 0) {
+        const installed = context.installedSkills;
+        const conflicting = skillInfo.conflicts.filter((c) => installed.includes(c));
+        for (const c of conflicting) {
+            warnings.push({
+                type: "skill-conflict",
+                message: `"${skillName}" conflicts with installed skill "${c}".`,
+                severity: "block",
+            });
+        }
+    }
+    // 2. Rule overlap: skill name matches existing .claude/rules/*.md filename
+    const ruleBasenames = context.ruleFiles.map((f) => f.replace(/\.md$/, "").toLowerCase());
+    if (ruleBasenames.includes(skillName.toLowerCase())) {
+        warnings.push({
+            type: "rule-overlap",
+            message: `A rule file "${skillName}.md" already exists in .claude/rules/. This skill may duplicate existing instructions.`,
+            severity: "warn",
+        });
+    }
+    // Also check if skill tags overlap heavily with rule file names
+    if (skillInfo?.tags) {
+        for (const tag of skillInfo.tags) {
+            if (ruleBasenames.includes(tag.toLowerCase()) && tag.toLowerCase() !== skillName.toLowerCase()) {
+                warnings.push({
+                    type: "rule-overlap",
+                    message: `Skill tag "${tag}" matches existing rule "${tag}.md". May overlap.`,
+                    severity: "warn",
+                });
+                break; // one warning is enough
+            }
+        }
+    }
+    // 3. Preference clash: check skill content against CLAUDE.md preferences
+    if (skillContent && context.preferences.length > 0) {
+        const contentLower = skillContent.toLowerCase();
+        for (const [a, b] of OPPOSING_PAIRS) {
+            const skillHasA = contentLower.includes(a);
+            const skillHasB = contentLower.includes(b);
+            const prefsHaveA = context.preferences.some((p) => p.toLowerCase().includes(a));
+            const prefsHaveB = context.preferences.some((p) => p.toLowerCase().includes(b));
+            if (skillHasA && prefsHaveB) {
+                warnings.push({
+                    type: "preference-clash",
+                    message: `Skill mentions "${a}" but your project prefers "${b}".`,
+                    severity: "warn",
+                });
+            }
+            else if (skillHasB && prefsHaveA) {
+                warnings.push({
+                    type: "preference-clash",
+                    message: `Skill mentions "${b}" but your project prefers "${a}".`,
+                    severity: "warn",
+                });
+            }
+        }
+    }
+    return warnings;
+}

package/dist/utils/errors.d.ts

@@ -3,4 +3,3 @@ export declare class CliError extends Error {
     readonly exitCode: number;
     constructor(message: string, code?: string, exitCode?: number);
 }
-//# sourceMappingURL=errors.d.ts.map