skiller 0.7.1 → 0.7.3

package/dist/core/SkillsProcessor.js

@@ -38,7 +38,10 @@ exports.syncMdcToSkillMd = syncMdcToSkillMd;
 exports.discoverSkills = discoverSkills;
 exports.getSkillsGitignorePaths = getSkillsGitignorePaths;
 exports.propagateSkills = propagateSkills;
+exports.migrateRulesToSkills = migrateRulesToSkills;
 exports.copySkillFoldersFromRules = copySkillFoldersFromRules;
+exports.copyMdcFilesFromRules = copyMdcFilesFromRules;
+exports.deleteRulesDir = deleteRulesDir;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
 const yaml = __importStar(require("js-yaml"));
@@ -140,8 +143,15 @@ async function syncMdcToSkillMd(skillsDir, verbose, dryRun) {
         }
         try {
             if (siblingMdcContent !== null && skillMdContent === null) {
-                // Case 1: Sibling .mdc exists but no SKILL.md → generate SKILL.md with @reference
+                // Case 1: Sibling .mdc exists but no SKILL.md
                 const { frontmatter: mdcFrontmatter } = (0, FrontmatterParser_1.parseFrontmatter)(siblingMdcContent);
+                // Skip SKILL.md generation for .mdc files with alwaysApply: true
+                // These are Cursor-style rules, not Claude Code skills
+                if (mdcFrontmatter?.alwaysApply === true) {
+                    (0, constants_1.logVerboseInfo)(`Skipping SKILL.md generation for ${skillName} (alwaysApply rule)`, verbose, dryRun);
+                    continue;
+                }
+                // Generate SKILL.md with @reference (absolute path)
                 const skillFrontmatter = {
                     name: skillName,
                     description: mdcFrontmatter?.description || `Skill: ${skillName}`,
@@ -150,14 +160,14 @@ async function syncMdcToSkillMd(skillsDir, verbose, dryRun) {
 ${yaml.dump(skillFrontmatter, { lineWidth: -1, noRefs: true }).trim()}
 ---
 
-@./${skillName}.mdc
+@.claude/skills/${skillName}/${skillName}.mdc
 `;
                 if (dryRun) {
                     (0, constants_1.logVerboseInfo)(`DRY RUN: Would generate ${skillName}/SKILL.md with @reference`, verbose, dryRun);
                 }
                 else {
                     await fs.writeFile(skillMdPath, newSkillMd, 'utf8');
-                    (0, constants_1.logVerboseInfo)(`Generated ${skillName}/SKILL.md with @./${skillName}.mdc reference`, verbose, dryRun);
+                    (0, constants_1.logVerboseInfo)(`Generated ${skillName}/SKILL.md with @.claude/skills/${skillName}/${skillName}.mdc reference`, verbose, dryRun);
                 }
                 synced.push(skillName);
             }
@@ -167,22 +177,32 @@ ${yaml.dump(skillFrontmatter, { lineWidth: -1, noRefs: true }).trim()}
                 const refCheck = isReferenceBody(skillBody);
                 if (refCheck.isReference) {
                     // Case 2: SKILL.md is @reference → source file is truth
-                    if (refCheck.referencePath === `./${skillName}.mdc`) {
+                    // Check for both relative and absolute sibling reference patterns
+                    const isRelativeSiblingRef = refCheck.referencePath === `./${skillName}.mdc`;
+                    const isAbsoluteSiblingRef = refCheck.referencePath ===
+                        `.claude/skills/${skillName}/${skillName}.mdc`;
+                    if (isRelativeSiblingRef || isAbsoluteSiblingRef) {
                         // Sibling reference pattern - validate/update frontmatter if .mdc changed
                         if (siblingMdcContent !== null) {
                             const { frontmatter: mdcFrontmatter } = (0, FrontmatterParser_1.parseFrontmatter)(siblingMdcContent);
                             // Update SKILL.md frontmatter if description changed in .mdc
-                            if (mdcFrontmatter?.description &&
-                                mdcFrontmatter.description !== skillFrontmatter?.description) {
+                            // Also migrate from relative to absolute path if needed
+                            const needsUpdate = (mdcFrontmatter?.description &&
+                                mdcFrontmatter.description !==
+                                    skillFrontmatter?.description) ||
+                                isRelativeSiblingRef; // Migrate old relative refs to absolute
+                            if (needsUpdate) {
                                 const newFrontmatter = {
                                     name: skillFrontmatter?.name || skillName,
-                                    description: mdcFrontmatter.description,
+                                    description: mdcFrontmatter?.description ||
+                                        skillFrontmatter?.description ||
+                                        `Skill: ${skillName}`,
                                 };
                                 const newSkillMd = `---
 ${yaml.dump(newFrontmatter, { lineWidth: -1, noRefs: true }).trim()}
 ---
 
-@./${skillName}.mdc
+@.claude/skills/${skillName}/${skillName}.mdc
 `;
                                 if (dryRun) {
                                     (0, constants_1.logVerboseInfo)(`DRY RUN: Would update ${skillName}/SKILL.md frontmatter from .mdc`, verbose, dryRun);
@@ -215,8 +235,7 @@ ${yaml.dump(newFrontmatter, { lineWidth: -1, noRefs: true }).trim()}
                             const { frontmatter: refFrontmatter, body: refBody } = (0, FrontmatterParser_1.parseFrontmatter)(referencedContent);
                             // Create sibling .mdc with the content
                             let mdcContent;
-                            if (refFrontmatter &&
-                                Object.keys(refFrontmatter).length > 0) {
+                            if (refFrontmatter && Object.keys(refFrontmatter).length > 0) {
                                 const mdcFrontmatterData = {};
                                 if (refFrontmatter.description) {
                                     mdcFrontmatterData.description = refFrontmatter.description;
@@ -242,7 +261,7 @@ ${refBody}
                             else {
                                 mdcContent = referencedContent;
                             }
-                            // Update SKILL.md to point to sibling .mdc
+                            // Update SKILL.md to point to sibling .mdc (absolute path)
                             const newFrontmatter = {
                                 name: skillFrontmatter?.name || skillName,
                                 description: refFrontmatter?.description ||
@@ -253,7 +272,7 @@ ${refBody}
 ${yaml.dump(newFrontmatter, { lineWidth: -1, noRefs: true }).trim()}
 ---
 
-@./${skillName}.mdc
+@.claude/skills/${skillName}/${skillName}.mdc
 `;
                             if (dryRun) {
                                 (0, constants_1.logVerboseInfo)(`DRY RUN: Would migrate ${skillName} from ${refCheck.referencePath} to sibling pattern`, verbose, dryRun);
@@ -290,7 +309,7 @@ ${skillBody}
                     else {
                         mdcContent = skillBody;
                     }
-                    // Update SKILL.md to @reference
+                    // Update SKILL.md to @reference (absolute path)
                     const newSkillFrontmatter = {
                         name: skillFrontmatter?.name || skillName,
                         description: skillFrontmatter?.description || `Skill: ${skillName}`,
@@ -299,7 +318,7 @@ ${skillBody}
 ${yaml.dump(newSkillFrontmatter, { lineWidth: -1, noRefs: true }).trim()}
 ---
 
-@./${skillName}.mdc
+@.claude/skills/${skillName}/${skillName}.mdc
 `;
                     if (dryRun) {
                         (0, constants_1.logVerboseInfo)(`DRY RUN: Would generate ${skillName}/${skillName}.mdc and update SKILL.md`, verbose, dryRun);
@@ -428,6 +447,27 @@ async function findSkillFoldersInRules(dir, depth = 0) {
     }
     return skillFolders;
 }
+/**
+ * Migrates all content from .claude/rules to .claude/skills and deletes the rules directory.
+ * This is the main entry point for rules migration - it only processes if rules directory exists.
+ */
+async function migrateRulesToSkills(skillerDir, verbose, dryRun) {
+    const rulesDir = path.join(skillerDir, 'rules');
+    // Check if rules directory exists - early exit if not
+    try {
+        await fs.access(rulesDir);
+    }
+    catch {
+        // No rules directory - nothing to migrate
+        return;
+    }
+    // Copy skill folders (folders with SKILL.md)
+    await copySkillFoldersFromRules(skillerDir, verbose, dryRun);
+    // Copy standalone .mdc files
+    await copyMdcFilesFromRules(skillerDir, verbose, dryRun);
+    // Delete the rules directory after migration
+    await deleteRulesDir(skillerDir, verbose, dryRun);
+}
 /**
  * Copies skill folders (folders containing SKILL.md) from .claude/rules to .claude/skills.
  * This allows users to organize skills in the rules directory and have them automatically
@@ -465,3 +505,103 @@ async function copySkillFoldersFromRules(skillerDir, verbose, dryRun) {
     }
     (0, constants_1.logVerboseInfo)(`Copied ${skillFolders.length} skill folder(s) from rules to skills`, verbose, dryRun);
 }
+/**
+ * Copies standalone .mdc files from .claude/rules to .claude/skills/name/name.mdc.
+ * These are rule files (not skill folders) that should be available in the skills directory.
+ * No SKILL.md is generated - these remain as .mdc files only.
+ */
+async function copyMdcFilesFromRules(skillerDir, verbose, dryRun) {
+    const rulesDir = path.join(skillerDir, 'rules');
+    const skillsDir = path.join(skillerDir, 'skills');
+    const copiedNames = [];
+    // Check if rules directory exists
+    try {
+        await fs.access(rulesDir);
+    }
+    catch {
+        return copiedNames;
+    }
+    const entries = await fs.readdir(rulesDir, { withFileTypes: true });
+    // Find .mdc files at rules root (not in subdirectories)
+    const mdcFiles = entries.filter((e) => e.isFile() && e.name.endsWith('.mdc'));
+    for (const mdcFile of mdcFiles) {
+        const skillName = path.basename(mdcFile.name, '.mdc');
+        const sourcePath = path.join(rulesDir, mdcFile.name);
+        const targetDir = path.join(skillsDir, skillName);
+        const targetPath = path.join(targetDir, mdcFile.name);
+        try {
+            const content = await fs.readFile(sourcePath, 'utf8');
+            // Parse and clean frontmatter - remove globs and alwaysApply: false
+            const { frontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(content);
+            let cleanedContent;
+            if (frontmatter && Object.keys(frontmatter).length > 0) {
+                const cleanedFrontmatter = {};
+                // Only keep description and alwaysApply: true
+                if (frontmatter.description) {
+                    cleanedFrontmatter.description = frontmatter.description;
+                }
+                if (frontmatter.alwaysApply === true) {
+                    cleanedFrontmatter.alwaysApply = true;
+                }
+                // Note: globs and alwaysApply: false are intentionally omitted
+                if (Object.keys(cleanedFrontmatter).length > 0) {
+                    cleanedContent = `---
+${yaml.dump(cleanedFrontmatter, { lineWidth: -1, noRefs: true }).trim()}
+---
+
+${body}
+`;
+                }
+                else {
+                    cleanedContent = body;
+                }
+            }
+            else {
+                cleanedContent = content;
+            }
+            if (dryRun) {
+                (0, constants_1.logVerboseInfo)(`DRY RUN: Would copy ${mdcFile.name} from rules to skills/${skillName}/${mdcFile.name}`, verbose, dryRun);
+            }
+            else {
+                await fs.mkdir(targetDir, { recursive: true });
+                await fs.writeFile(targetPath, cleanedContent, 'utf8');
+                (0, constants_1.logVerboseInfo)(`Copied ${mdcFile.name} from rules to skills/${skillName}/${mdcFile.name}`, verbose, dryRun);
+            }
+            copiedNames.push(skillName);
+        }
+        catch (err) {
+            (0, constants_1.logWarn)(`Failed to copy ${mdcFile.name}: ${err.message}`, dryRun);
+        }
+    }
+    if (copiedNames.length > 0) {
+        (0, constants_1.logVerboseInfo)(`Copied ${copiedNames.length} .mdc file(s) from rules to skills`, verbose, dryRun);
+    }
+    return copiedNames;
+}
+/**
+ * Deletes the .claude/rules directory after content has been migrated to .claude/skills.
+ * This completes the migration from the old rules-based structure to the new skills-based structure.
+ */
+async function deleteRulesDir(skillerDir, verbose, dryRun) {
+    const rulesDir = path.join(skillerDir, 'rules');
+    // Check if rules directory exists
+    try {
+        await fs.access(rulesDir);
+    }
+    catch {
+        return false; // No rules directory to delete
+    }
+    if (dryRun) {
+        (0, constants_1.logVerboseInfo)(`DRY RUN: Would delete .claude/rules directory after migration`, verbose, dryRun);
+        return true;
+    }
+    try {
+        await fs.rm(rulesDir, { recursive: true, force: true });
+        (0, constants_1.logVerboseInfo)(`Deleted .claude/rules directory after migration to .claude/skills`, verbose, dryRun);
+        return true;
+    }
+    catch (err) {
+        (0, constants_1.logWarn)(`Failed to delete .claude/rules: ${err.message}`, dryRun);
+        return false;
+    }
+}

package/dist/core/SkillsUtils.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasSkillMd = hasSkillMd;
+exports.hasAlwaysApplyMdc = hasAlwaysApplyMdc;
 exports.isGroupingDir = isGroupingDir;
 exports.walkSkillsTree = walkSkillsTree;
 exports.formatValidationWarnings = formatValidationWarnings;
@@ -42,6 +43,7 @@ exports.copySkillsDirectoryWithTransform = copySkillsDirectoryWithTransform;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
 const constants_1 = require("../constants");
+const FrontmatterParser_1 = require("./FrontmatterParser");
 /**
  * Checks if a directory contains a SKILL.md file.
  */
@@ -55,6 +57,30 @@ async function hasSkillMd(dirPath) {
         return false;
     }
 }
+/**
+ * Checks if a directory contains an .mdc file with alwaysApply: true.
+ * These directories are valid without SKILL.md since alwaysApply rules
+ * are Cursor-style rules, not Claude Code skills.
+ */
+async function hasAlwaysApplyMdc(dirPath) {
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.mdc')) {
+                const mdcPath = path.join(dirPath, entry.name);
+                const content = await fs.readFile(mdcPath, 'utf8');
+                const { frontmatter } = (0, FrontmatterParser_1.parseFrontmatter)(content);
+                if (frontmatter?.alwaysApply === true) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Checks if a directory is a grouping directory (contains subdirectories with SKILL.md).
  */
@@ -121,8 +147,12 @@ async function walkSkillsTree(root) {
                     await walk(entryPath, entryRelativePath, depth + 1);
                 }
                 else {
-                    // This is neither a skill nor a grouping directory - warn about it
-                    warnings.push(`Directory '${entryRelativePath}' in .claude/skills has no SKILL.md and contains no sub-skills. It may be malformed or stray.`);
+                    // Check if this is a valid alwaysApply directory (no SKILL.md expected)
+                    const hasAlwaysApply = await hasAlwaysApplyMdc(entryPath);
+                    if (!hasAlwaysApply) {
+                        // This is neither a skill nor a grouping directory - warn about it
+                        warnings.push(`Directory '${entryRelativePath}' in .claude/skills has no SKILL.md and contains no sub-skills. It may be malformed or stray.`);
+                    }
                 }
             }
         }

package/dist/lib.js

@@ -102,11 +102,11 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
         (0, constants_1.logVerbose)(`Selected ${selectedAgents.length} agents: ${selectedAgents.map((a) => a.getName()).join(', ')}`, verbose);
         // Propagate skills (or cleanup if disabled) - do this for each nested directory
         const skillsEnabledResolved = resolveSkillsEnabled(skillsEnabled, rootConfig.skills?.enabled);
-        const { propagateSkills, copySkillFoldersFromRules } = await Promise.resolve().then(() => __importStar(require('./core/SkillsProcessor')));
-        // Copy skill folders from rules to skills
+        const { propagateSkills, migrateRulesToSkills } = await Promise.resolve().then(() => __importStar(require('./core/SkillsProcessor')));
+        // Migrate content from .claude/rules to .claude/skills (only if rules exists)
         if (skillsEnabledResolved) {
             for (const configEntry of hierarchicalConfigs) {
-                await copySkillFoldersFromRules(configEntry.skillerDir, verbose, dryRun);
+                await migrateRulesToSkills(configEntry.skillerDir, verbose, dryRun);
             }
         }
         // Propagate skills for each nested .claude directory (or cleanup if disabled)
@@ -130,10 +130,10 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
         (0, constants_1.logVerbose)(`Selected ${selectedAgents.length} agents: ${selectedAgents.map((a) => a.getName()).join(', ')}`, verbose);
         // Propagate skills (or cleanup if disabled)
         const skillsEnabledResolved = resolveSkillsEnabled(skillsEnabled, singleConfig.config.skills?.enabled);
-        const { propagateSkills, copySkillFoldersFromRules } = await Promise.resolve().then(() => __importStar(require('./core/SkillsProcessor')));
-        // Copy skill folders from rules to skills
+        const { propagateSkills, migrateRulesToSkills } = await Promise.resolve().then(() => __importStar(require('./core/SkillsProcessor')));
+        // Migrate content from .claude/rules to .claude/skills (only if rules exists)
         if (skillsEnabledResolved) {
-            await copySkillFoldersFromRules(singleConfig.skillerDir, verbose, dryRun);
+            await migrateRulesToSkills(singleConfig.skillerDir, verbose, dryRun);
         }
         // Always call propagateSkills - it handles cleanup when disabled
         await propagateSkills(projectRoot, selectedAgents, skillsEnabledResolved, verbose, dryRun, singleConfig.skillerDir);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "skiller",
-	"version": "0.7.1",
+	"version": "0.7.3",
 	"description": "Skiller — apply the same rules to all coding agents",
 	"main": "dist/lib.js",
 	"publishConfig": {