skiller 0.7.14 → 0.7.16

package/README.md

@@ -59,11 +59,21 @@ A Claude-centric fork of [ruler](https://github.com/intellectronica/ruler) with
 - Reads `.claude/settings.json` `enabledPlugins`
 - Syncs enabled plugin `skills/` into agent skills directories on `skiller apply`
 - Syncs enabled plugin `commands/*.md` as skills (`SKILL.md`) into agent skills directories
-- Uses the skill/command name by default (matches existing Codex skill names)
-- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginId>__<name>`
+- Syncs enabled plugin `agents/**/*.md` as skills (`SKILL.md`) into agent skills directories
+- Uses the skill/command/agent name by default (matches existing Codex skill names)
+- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginId>-<name>`
 - Tracks plugin-managed skills in a single `.skiller-plugins.json` file per agent skills directory
 - Removes stale plugin skills when plugins are disabled
 
+## 10. Claude Commands/Agents → Skills
+
+- Syncs `.claude/commands/**/*.md` as skills (`SKILL.md`) into agent skills directories
+- Syncs `.claude/agents/**/*.md` as skills (`SKILL.md`) into agent skills directories
+- Uses the command/agent name by default
+- If a name conflicts, existing local/manual skills win and the project item is namespaced as `claude-<name>`
+- Project items win over plugin skills/commands/agents on name conflicts
+- Tracks project-managed items in a single `.skiller-claude.json` file per agent skills directory
+
 ---
 
 # Skiller: Centralise Your AI Coding Assistant Instructions
@@ -596,7 +606,7 @@ If your project enables Claude Code plugins in `.claude/settings.json`, Skiller
 - Plugin `skills/` are copied as skills
 - Plugin `commands/*.md` are converted into skills (`SKILL.md`)
 - Plugin skills use their original skill/command name by default
-- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginId>__<name>`
+- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginId>-<name>`
 - Plugin-managed skills are tracked via `.skiller-plugins.json` in each agent skills directory
 
 ### Skills Directory Structure

package/dist/core/ClaudePluginSync.js

@@ -38,6 +38,7 @@ exports.readInstalledPluginsIndex = readInstalledPluginsIndex;
 exports.resolvePluginInstall = resolvePluginInstall;
 exports.discoverPluginSkillDirs = discoverPluginSkillDirs;
 exports.discoverPluginCommandFiles = discoverPluginCommandFiles;
+exports.discoverPluginAgentFiles = discoverPluginAgentFiles;
 exports.syncClaudePluginsToSkillsDirs = syncClaudePluginsToSkillsDirs;
 const fs = __importStar(require("fs/promises"));
 const os = __importStar(require("os"));
@@ -141,8 +142,24 @@ function resolvePluginInstall(pluginId, projectRoot, index) {
         };
     }
     const userCandidates = entries.filter((e) => e && e.scope === 'user');
-    if (userCandidates.length === 0)
-        return null;
+    if (userCandidates.length === 0) {
+        // Fallback: if the plugin is installed for a different project but enabled
+        // here, still use the newest available install. This avoids noisy
+        // "not installed" warnings for plugins that don't ship skills/commands.
+        const anyCandidates = entries.filter((e) => e && typeof e.installPath === 'string' && e.installPath.length > 0);
+        if (anyCandidates.length === 0)
+            return null;
+        anyCandidates.sort((a, b) => {
+            const at = parseDate(a.lastUpdated) || parseDate(a.installedAt);
+            const bt = parseDate(b.lastUpdated) || parseDate(b.installedAt);
+            return bt - at;
+        });
+        return {
+            pluginId,
+            installPath: anyCandidates[0].installPath,
+            version: anyCandidates[0].version,
+        };
+    }
     userCandidates.sort((a, b) => {
         const at = parseDate(a.lastUpdated) || parseDate(a.installedAt);
         const bt = parseDate(b.lastUpdated) || parseDate(b.installedAt);
@@ -203,6 +220,49 @@ async function discoverPluginCommandFiles(installPath) {
         file: path.join(commandsRoot, e.name),
     }));
 }
+async function discoverPluginAgentFiles(installPath) {
+    const agentsRoot = path.join(installPath, 'agents');
+    if (!(await fileExists(agentsRoot)))
+        return [];
+    const results = [];
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            let content;
+            try {
+                content = await fs.readFile(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const parsed = (0, FrontmatterParser_1.parseFrontmatter)(content);
+            const fmName = parsed.rawFrontmatter && typeof parsed.rawFrontmatter.name === 'string'
+                ? parsed.rawFrontmatter.name
+                : parsed.frontmatter?.name;
+            if (typeof fmName !== 'string' || fmName.trim() === '')
+                continue;
+            const rel = path.relative(agentsRoot, full).replace(/\\/g, '/');
+            results.push({ name: fmName.trim(), file: full, rel });
+        }
+    }
+    await walk(agentsRoot, 0);
+    return results;
+}
 function generateBaseNameFromRelId(relId) {
     const normalized = relId.replace(/\\/g, '/');
     const segments = normalized.split('/').filter(Boolean);
@@ -212,7 +272,7 @@ function generateBaseNameFromCommand(commandName) {
     return sanitizeId(commandName);
 }
 function generateNamespacedName(pluginId, baseName) {
-    return `${sanitizeId(pluginId)}__${baseName}`;
+    return `${sanitizeId(pluginId)}-${baseName}`;
 }
 async function readManifestFile(targetSkillsDir) {
     const manifestPath = path.join(targetSkillsDir, MANIFEST_FILENAME);
@@ -233,7 +293,9 @@ async function readManifestFile(targetSkillsDir) {
             if (typeof e.pluginId !== 'string')
                 continue;
             const sourceKind = e.sourceKind;
-            if (sourceKind !== 'skill' && sourceKind !== 'command')
+            if (sourceKind !== 'skill' &&
+                sourceKind !== 'command' &&
+                sourceKind !== 'agent')
                 continue;
             if (typeof e.sourceRelPath !== 'string')
                 continue;
@@ -294,7 +356,9 @@ async function readLegacyMarkerFile(dir) {
             return null;
         if (typeof obj.generatedName !== 'string')
             return null;
-        if (obj.sourceKind !== 'skill' && obj.sourceKind !== 'command')
+        if (obj.sourceKind !== 'skill' &&
+            obj.sourceKind !== 'command' &&
+            obj.sourceKind !== 'agent')
             return null;
         if (typeof obj.sourceRelPath !== 'string')
             return null;
@@ -390,6 +454,77 @@ async function discoverLocalSkillNames(projectRoot) {
     await walk(localSkillsDir, 0);
     return names;
 }
+async function discoverLocalCommandNames(projectRoot) {
+    const localCommandsDir = path.join(projectRoot, '.claude', 'commands');
+    if (!(await fileExists(localCommandsDir)))
+        return new Set();
+    const names = new Set();
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            names.add(sanitizeId(path.basename(entry.name, '.md')));
+        }
+    }
+    await walk(localCommandsDir, 0);
+    return names;
+}
+async function discoverLocalAgentNames(projectRoot) {
+    const localAgentsDir = path.join(projectRoot, '.claude', 'agents');
+    if (!(await fileExists(localAgentsDir)))
+        return new Set();
+    const names = new Set();
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            let content;
+            try {
+                content = await fs.readFile(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const parsed = (0, FrontmatterParser_1.parseFrontmatter)(content);
+            const fmName = parsed.rawFrontmatter && typeof parsed.rawFrontmatter.name === 'string'
+                ? parsed.rawFrontmatter.name
+                : parsed.frontmatter?.name;
+            if (typeof fmName !== 'string' || fmName.trim() === '')
+                continue;
+            names.add(sanitizeId(fmName.trim()));
+        }
+    }
+    await walk(localAgentsDir, 0);
+    return names;
+}
 async function ensureDir(dir, dryRun) {
     if (dryRun)
         return;
@@ -423,15 +558,15 @@ async function rewriteSkillMdName(skillMdPath, name, pluginId, dryRun) {
         return;
     await fs.writeFile(skillMdPath, next, 'utf8');
 }
-async function writeCommandAsSkill(srcCommandPath, destDir, generatedName, pluginId, dryRun) {
-    const content = await fs.readFile(srcCommandPath, 'utf8');
+async function writeMarkdownAsSkill(srcMarkdownPath, destDir, generatedName, pluginId, kindLabel, dryRun) {
+    const content = await fs.readFile(srcMarkdownPath, 'utf8');
     const { rawFrontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(content);
     const fm = rawFrontmatter
         ? { ...rawFrontmatter }
         : {};
     fm.name = generatedName;
     if (typeof fm.description !== 'string' || fm.description.trim() === '') {
-        fm.description = `Command from ${pluginId}: ${path.basename(srcCommandPath, '.md')}`;
+        fm.description = `${kindLabel} from ${pluginId}: ${path.basename(srcMarkdownPath, '.md')}`;
     }
     const next = `---\n${yaml
         .dump(fm, { lineWidth: -1, noRefs: true })
@@ -450,6 +585,13 @@ async function syncClaudePluginsToSkillsDirs(args) {
     const claudeDir = path.join(getUserHomeDir(), '.claude');
     const index = await readInstalledPluginsIndex(claudeDir);
     const localSkillNames = await discoverLocalSkillNames(projectRoot);
+    const localCommandNames = await discoverLocalCommandNames(projectRoot);
+    const localAgentNames = await discoverLocalAgentNames(projectRoot);
+    const localReservedNames = new Set([
+        ...localSkillNames,
+        ...localCommandNames,
+        ...localAgentNames,
+    ]);
     // If we can't read the installed plugins index, we can't install/update
     // anything, but we can still clean up managed folders for plugins that
     // are no longer enabled.
@@ -460,7 +602,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
             const managedEntries = await loadManagedEntries(targetSkillsDir, dryRun);
             const nextEntries = [];
             // Build reserved set (local skills always win).
-            const reserved = new Set(localSkillNames);
+            const reserved = new Set(localReservedNames);
             // Also reserve any existing non-managed directories.
             const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
             let dirents = [];
@@ -537,6 +679,20 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 baseName,
             });
         }
+        const agentFiles = await discoverPluginAgentFiles(plugin.installPath);
+        for (const a of agentFiles) {
+            const baseName = sanitizeId(a.name);
+            const sourceRelPath = `agents/${a.rel}`;
+            expectedItems.push({
+                itemKey: makeItemKey(plugin.pluginId, 'agent', sourceRelPath),
+                pluginId: plugin.pluginId,
+                pluginVersion: plugin.version,
+                kind: 'agent',
+                sourcePath: a.file,
+                sourceRelPath,
+                baseName,
+            });
+        }
     }
     const sortedItems = [...expectedItems].sort((a, b) => {
         const ak = `${a.baseName}::${a.pluginId}::${a.kind}::${a.sourceRelPath}`;
@@ -558,7 +714,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
         }
         const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
         // Reserve: local skills always win. Also reserve any existing non-managed folders.
-        const reserved = new Set(localSkillNames);
+        const reserved = new Set(localReservedNames);
         if (targetExists) {
             let dirents = [];
             try {
@@ -583,6 +739,11 @@ async function syncClaudePluginsToSkillsDirs(args) {
             const prev = prevDestByItemKey.get(item.itemKey);
             if (!prev)
                 continue;
+            // Migration: previous versions used `${pluginId}__${name}`.
+            // Don't preserve legacy namespaced destinations so we can rename to the
+            // new `${pluginId}-${name}` format.
+            if (prev.startsWith(`${sanitizeId(item.pluginId)}__`))
+                continue;
             if (taken.has(prev))
                 continue;
             assignedDestByItemKey.set(item.itemKey, prev);
@@ -602,7 +763,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
             let candidate = namespacedBase;
             let i = 2;
             while (taken.has(candidate)) {
-                candidate = `${namespacedBase}__${i++}`;
+                candidate = `${namespacedBase}-${i++}`;
             }
             assignedDestByItemKey.set(item.itemKey, candidate);
             taken.add(candidate);
@@ -642,12 +803,13 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 await removeLegacyMarkerFile(destDir, dryRun);
             }
             else {
+                const kindLabel = item.kind === 'command' ? 'command' : 'agent';
                 (0, constants_1.logVerboseInfo)(dryRun
-                    ? `DRY RUN: Would install plugin command '${destRelPath}' as skill to ${targetSkillsDir}`
-                    : `Installing plugin command '${destRelPath}' as skill to ${targetSkillsDir}`, verbose, dryRun);
+                    ? `DRY RUN: Would install plugin ${kindLabel} '${destRelPath}' as skill to ${targetSkillsDir}`
+                    : `Installing plugin ${kindLabel} '${destRelPath}' as skill to ${targetSkillsDir}`, verbose, dryRun);
                 await ensureDir(destDir, dryRun);
                 if (!dryRun) {
-                    await writeCommandAsSkill(item.sourcePath, destDir, destRelPath, item.pluginId, dryRun);
+                    await writeMarkdownAsSkill(item.sourcePath, destDir, destRelPath, item.pluginId, item.kind === 'command' ? 'Command' : 'Agent', dryRun);
                 }
                 await removeLegacyMarkerFile(destDir, dryRun);
             }

package/dist/core/ClaudeProjectSync.js

@@ -0,0 +1,460 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncClaudeProjectCommandsAndAgentsToSkillsDirs = syncClaudeProjectCommandsAndAgentsToSkillsDirs;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const constants_1 = require("../constants");
+const FrontmatterParser_1 = require("./FrontmatterParser");
+const MANIFEST_FILENAME = '.skiller-claude.json';
+const MANIFEST_VERSION = 1;
+const LEGACY_PLUGIN_MARKER_FILENAME = '.skiller-plugin.json';
+function sanitizeId(value) {
+    return value.replace(/[^A-Za-z0-9._-]+/g, '_');
+}
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function makeItemKey(sourceKind, sourceRelPath) {
+    return `${sourceKind}::${sourceRelPath}`;
+}
+function getCommandsRoot(projectRoot) {
+    return path.join(projectRoot, '.claude', 'commands');
+}
+function getAgentsRoot(projectRoot) {
+    return path.join(projectRoot, '.claude', 'agents');
+}
+async function discoverCommandFiles(projectRoot) {
+    const commandsRoot = getCommandsRoot(projectRoot);
+    if (!(await fileExists(commandsRoot)))
+        return [];
+    const results = [];
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            const name = sanitizeId(path.basename(entry.name, '.md'));
+            const rel = path.relative(projectRoot, full).replace(/\\/g, '/');
+            results.push({ name, file: full, rel });
+        }
+    }
+    await walk(commandsRoot, 0);
+    return results;
+}
+async function discoverAgentFiles(projectRoot) {
+    const agentsRoot = getAgentsRoot(projectRoot);
+    if (!(await fileExists(agentsRoot)))
+        return [];
+    const results = [];
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            let content;
+            try {
+                content = await fs.readFile(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const parsed = (0, FrontmatterParser_1.parseFrontmatter)(content);
+            const fmName = parsed.rawFrontmatter && typeof parsed.rawFrontmatter.name === 'string'
+                ? parsed.rawFrontmatter.name
+                : parsed.frontmatter?.name;
+            if (typeof fmName !== 'string' || fmName.trim() === '')
+                continue;
+            const name = sanitizeId(fmName.trim());
+            const rel = path.relative(projectRoot, full).replace(/\\/g, '/');
+            results.push({ name, file: full, rel });
+        }
+    }
+    await walk(agentsRoot, 0);
+    return results;
+}
+async function readManifestFile(targetSkillsDir) {
+    const manifestPath = path.join(targetSkillsDir, MANIFEST_FILENAME);
+    try {
+        const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+        if (!raw || typeof raw !== 'object')
+            return null;
+        const obj = raw;
+        if (typeof obj.version !== 'number')
+            return null;
+        if (!Array.isArray(obj.entries))
+            return null;
+        const entries = [];
+        for (const entry of obj.entries) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const e = entry;
+            if (e.sourceKind !== 'command' && e.sourceKind !== 'agent')
+                continue;
+            if (typeof e.sourceRelPath !== 'string')
+                continue;
+            if (typeof e.destRelPath !== 'string')
+                continue;
+            entries.push({
+                sourceKind: e.sourceKind,
+                sourceRelPath: e.sourceRelPath,
+                destRelPath: e.destRelPath,
+            });
+        }
+        return {
+            version: obj.version,
+            entries,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeManifestFile(targetSkillsDir, entries, dryRun) {
+    const manifestPath = path.join(targetSkillsDir, MANIFEST_FILENAME);
+    if (entries.length === 0) {
+        if (dryRun)
+            return;
+        try {
+            await fs.unlink(manifestPath);
+        }
+        catch {
+            // ignore
+        }
+        return;
+    }
+    const manifest = {
+        version: MANIFEST_VERSION,
+        entries: [...entries].sort((a, b) => {
+            const ak = `${a.destRelPath}::${a.sourceKind}::${a.sourceRelPath}`;
+            const bk = `${b.destRelPath}::${b.sourceKind}::${b.sourceRelPath}`;
+            return ak.localeCompare(bk);
+        }),
+    };
+    if (dryRun)
+        return;
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+}
+async function ensureDir(dir, dryRun) {
+    if (dryRun)
+        return;
+    await fs.mkdir(dir, { recursive: true });
+}
+async function removeDir(dir, dryRun) {
+    if (dryRun)
+        return;
+    await fs.rm(dir, { recursive: true, force: true });
+}
+async function writeMarkdownAsSkill(srcPath, destDir, generatedName, kindLabel, dryRun) {
+    const content = await fs.readFile(srcPath, 'utf8');
+    const { rawFrontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(content);
+    const fm = rawFrontmatter
+        ? { ...rawFrontmatter }
+        : {};
+    fm.name = generatedName;
+    if (typeof fm.description !== 'string' || fm.description.trim() === '') {
+        fm.description = `${kindLabel}: ${path.basename(srcPath, '.md')}`;
+    }
+    const next = `---\n${yaml
+        .dump(fm, { lineWidth: -1, noRefs: true })
+        .trim()}\n---\n\n${body}\n`;
+    if (dryRun)
+        return;
+    await fs.writeFile(path.join(destDir, 'SKILL.md'), next, 'utf8');
+}
+async function readPluginManagedDestNames(targetSkillsDir) {
+    const manifestPath = path.join(targetSkillsDir, '.skiller-plugins.json');
+    const names = new Set();
+    try {
+        const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+        if (raw && typeof raw === 'object') {
+            const obj = raw;
+            if (Array.isArray(obj.entries)) {
+                for (const entry of obj.entries) {
+                    if (!entry || typeof entry !== 'object')
+                        continue;
+                    const e = entry;
+                    if (typeof e.destRelPath === 'string' && e.destRelPath.length > 0) {
+                        names.add(e.destRelPath);
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    // Legacy: prior versions wrote per-skill plugin marker files. Treat any
+    // folder containing one as plugin-managed so project items can take over.
+    try {
+        const dirents = await fs.readdir(targetSkillsDir, { withFileTypes: true });
+        for (const d of dirents) {
+            if (!d.isDirectory())
+                continue;
+            try {
+                await fs.access(path.join(targetSkillsDir, d.name, LEGACY_PLUGIN_MARKER_FILENAME));
+                names.add(d.name);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return names;
+}
+async function discoverLocalSkillNames(projectRoot) {
+    const localSkillsDir = path.join(projectRoot, '.claude', 'skills');
+    if (!(await fileExists(localSkillsDir)))
+        return new Set();
+    const names = new Set();
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const hasSkillMd = entries.some((e) => e.isFile() && e.name === 'SKILL.md');
+        if (hasSkillMd) {
+            names.add(path.basename(current));
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            await walk(path.join(current, entry.name), depth + 1);
+        }
+    }
+    await walk(localSkillsDir, 0);
+    return names;
+}
+async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
+    const { projectRoot, targetSkillsDirs, verbose, dryRun } = args;
+    const localSkillNames = await discoverLocalSkillNames(projectRoot);
+    const commands = await discoverCommandFiles(projectRoot);
+    const agents = await discoverAgentFiles(projectRoot);
+    const expectedItems = [];
+    for (const cmd of commands) {
+        expectedItems.push({
+            itemKey: makeItemKey('command', cmd.rel),
+            sourceKind: 'command',
+            sourcePath: cmd.file,
+            sourceRelPath: cmd.rel,
+            baseName: cmd.name,
+        });
+    }
+    for (const agent of agents) {
+        expectedItems.push({
+            itemKey: makeItemKey('agent', agent.rel),
+            sourceKind: 'agent',
+            sourcePath: agent.file,
+            sourceRelPath: agent.rel,
+            baseName: agent.name,
+        });
+    }
+    const sortedItems = [...expectedItems].sort((a, b) => {
+        const ak = `${a.baseName}::${a.sourceKind}::${a.sourceRelPath}`;
+        const bk = `${b.baseName}::${b.sourceKind}::${b.sourceRelPath}`;
+        return ak.localeCompare(bk);
+    });
+    for (const targetSkillsDir of targetSkillsDirs) {
+        const targetExists = await fileExists(targetSkillsDir);
+        const managedEntries = targetExists
+            ? ((await readManifestFile(targetSkillsDir))?.entries ?? [])
+            : [];
+        const prevDestByItemKey = new Map();
+        for (const entry of managedEntries) {
+            prevDestByItemKey.set(makeItemKey(entry.sourceKind, entry.sourceRelPath), entry.destRelPath);
+        }
+        const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
+        const pluginManagedDest = targetExists
+            ? await readPluginManagedDestNames(targetSkillsDir)
+            : new Set();
+        const reserved = new Set(localSkillNames);
+        if (targetExists) {
+            let dirents = [];
+            try {
+                dirents = await fs.readdir(targetSkillsDir, { withFileTypes: true });
+            }
+            catch {
+                dirents = [];
+            }
+            for (const d of dirents) {
+                if (!d.isDirectory())
+                    continue;
+                // Reserve any existing folder we do not manage, except plugin-managed
+                // folders (project should be able to take those over).
+                if (!managedDest.has(d.name) && !pluginManagedDest.has(d.name)) {
+                    reserved.add(d.name);
+                }
+            }
+        }
+        const taken = new Set(reserved);
+        const assignedDestByItemKey = new Map();
+        // Preserve previous destinations when they are still available.
+        for (const item of sortedItems) {
+            const prev = prevDestByItemKey.get(item.itemKey);
+            if (!prev)
+                continue;
+            // Migration: previous versions used `claude__<name>`.
+            // Don't preserve legacy namespaced destinations so we can rename to the
+            // new `claude-<name>` format.
+            if (prev.startsWith('claude__'))
+                continue;
+            if (taken.has(prev))
+                continue;
+            assignedDestByItemKey.set(item.itemKey, prev);
+            taken.add(prev);
+        }
+        // Assign baseName, otherwise namespace with "claude-".
+        for (const item of sortedItems) {
+            if (assignedDestByItemKey.has(item.itemKey))
+                continue;
+            const base = item.baseName;
+            if (!taken.has(base)) {
+                assignedDestByItemKey.set(item.itemKey, base);
+                taken.add(base);
+                continue;
+            }
+            const namespacedBase = `claude-${base}`;
+            let candidate = namespacedBase;
+            let i = 2;
+            while (taken.has(candidate)) {
+                candidate = `${namespacedBase}-${i++}`;
+            }
+            assignedDestByItemKey.set(item.itemKey, candidate);
+            taken.add(candidate);
+        }
+        const assignedItems = sortedItems.map((item) => ({
+            ...item,
+            destRelPath: assignedDestByItemKey.get(item.itemKey),
+        }));
+        if (assignedItems.length > 0) {
+            await ensureDir(targetSkillsDir, dryRun);
+        }
+        else if (!targetExists && managedEntries.length === 0) {
+            // Nothing to do.
+            continue;
+        }
+        // Install/update expected items
+        for (const item of assignedItems) {
+            const destRelPath = item.destRelPath;
+            const destDir = path.join(targetSkillsDir, destRelPath);
+            if (await fileExists(destDir)) {
+                const isManagedByProject = managedDest.has(destRelPath);
+                const isManagedByPlugin = pluginManagedDest.has(destRelPath);
+                if (!isManagedByProject && !isManagedByPlugin) {
+                    (0, constants_1.logWarn)(`[claude] Destination exists but is not skiller-managed, skipping: ${destDir}`, dryRun);
+                    continue;
+                }
+                (0, constants_1.logVerboseInfo)(dryRun
+                    ? `DRY RUN: Would update claude ${item.sourceKind} '${destRelPath}' in ${targetSkillsDir}`
+                    : `Updating claude ${item.sourceKind} '${destRelPath}' in ${targetSkillsDir}`, verbose, dryRun);
+                await removeDir(destDir, dryRun);
+            }
+            (0, constants_1.logVerboseInfo)(dryRun
+                ? `DRY RUN: Would install claude ${item.sourceKind} '${destRelPath}' to ${targetSkillsDir}`
+                : `Installing claude ${item.sourceKind} '${destRelPath}' to ${targetSkillsDir}`, verbose, dryRun);
+            await ensureDir(destDir, dryRun);
+            if (!dryRun) {
+                await writeMarkdownAsSkill(item.sourcePath, destDir, destRelPath, item.sourceKind === 'command' ? 'Command' : 'Agent', dryRun);
+            }
+        }
+        // Cleanup stale managed folders
+        const expectedDest = new Set(assignedItems.map((i) => i.destRelPath));
+        const nextEntries = [];
+        for (const entry of managedEntries) {
+            if (expectedDest.has(entry.destRelPath)) {
+                // Still expected; re-add below.
+                continue;
+            }
+            if (reserved.has(entry.destRelPath)) {
+                // User/local took over the folder name; stop managing it but don't delete.
+                continue;
+            }
+            (0, constants_1.logVerboseInfo)(dryRun
+                ? `DRY RUN: Would remove stale claude skill '${entry.destRelPath}' from ${targetSkillsDir}`
+                : `Removing stale claude skill '${entry.destRelPath}' from ${targetSkillsDir}`, verbose, dryRun);
+            await removeDir(path.join(targetSkillsDir, entry.destRelPath), dryRun);
+        }
+        for (const item of assignedItems) {
+            nextEntries.push({
+                sourceKind: item.sourceKind,
+                sourceRelPath: item.sourceRelPath,
+                destRelPath: item.destRelPath,
+            });
+        }
+        await writeManifestFile(targetSkillsDir, nextEntries, dryRun);
+    }
+}

package/dist/core/SkillsProcessor.js

@@ -589,6 +589,17 @@ async function propagateSkills(projectRoot, agents, skillsEnabled, verbose, dryR
             }
         }
     }
+    // Sync project Claude commands + agents as skills into agent skills dirs.
+    // This intentionally does NOT write into the committed .claude/skills source-of-truth.
+    if (destinationPaths.size > 0) {
+        const { syncClaudeProjectCommandsAndAgentsToSkillsDirs } = await Promise.resolve().then(() => __importStar(require('./ClaudeProjectSync')));
+        await syncClaudeProjectCommandsAndAgentsToSkillsDirs({
+            projectRoot,
+            targetSkillsDirs: [...destinationPaths],
+            verbose,
+            dryRun,
+        });
+    }
     // Sync Claude plugins (skills + commands converted to skills) into agent skills dirs.
     // This intentionally does NOT write into the committed .claude/skills source-of-truth.
     if (destinationPaths.size > 0) {

package/package.json

@@ -1,79 +1,79 @@
 {
-	"name": "skiller",
-	"version": "0.7.14",
-	"description": "Sync Claude skills and plugins to all coding agents",
-	"main": "dist/lib.js",
-	"publishConfig": {
-		"access": "public"
-	},
-	"scripts": {
-		"postinstall": "[ -n \"$CI\" ] || npx skiller@latest apply",
-		"lint": "eslint \"src/**/*.{ts,tsx}\"",
-		"lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
-		"format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
-		"test": "jest",
-		"test:watch": "jest --watch",
-		"test:coverage": "jest --coverage",
-		"test:integration": "jest tests/e2e/skiller.integration.test.ts --verbose",
-		"build": "tsc",
-		"release": "pnpm build && pnpm changeset publish"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/udecode/skiller.git"
-	},
-	"keywords": [
-		"ai",
-		"developer-tools",
-		"copilot",
-		"codex",
-		"claude",
-		"cursor",
-		"aider",
-		"config",
-		"rules",
-		"automation"
-	],
-	"author": "Eleanor Berger",
-	"license": "MIT",
-	"bugs": {
-		"url": "https://github.com/udecode/skiller/issues"
-	},
-	"engines": {
-		"node": ">=18"
-	},
-	"files": [
-		"dist",
-		"README.md",
-		"LICENSE"
-	],
-	"bin": {
-		"skiller": "dist/cli/index.js"
-	},
-	"devDependencies": {
-		"@changesets/changelog-github": "^0.5.2",
-		"@changesets/cli": "2.29.8",
-		"@eslint/js": "^9.39.1",
-		"@types/iarna__toml": "^2.0.5",
-		"@types/jest": "^29.5.14",
-		"@types/js-yaml": "^4.0.9",
-		"@types/node": "^24.9.2",
-		"@types/yargs": "^17.0.34",
-		"@typescript-eslint/eslint-plugin": "^8.46.2",
-		"@typescript-eslint/parser": "^8.46.2",
-		"eslint": "^9.38.0",
-		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-prettier": "^5.5.4",
-		"jest": "^29.7.0",
-		"prettier": "^3.6.2",
-		"ts-jest": "^29.4.5",
-		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.46.2"
-	},
-	"dependencies": {
-		"@iarna/toml": "^2.2.5",
-		"js-yaml": "^4.1.0",
-		"yargs": "^18.0.0",
-		"zod": "^4.1.12"
-	}
+  "name": "skiller",
+  "version": "0.7.16",
+  "description": "Skiller — apply the same rules to all coding agents",
+  "main": "dist/lib.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "postinstall": "[ -n \"$CI\" ] || npx skiller@latest apply",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:integration": "jest tests/e2e/skiller.integration.test.ts --verbose",
+    "build": "tsc",
+    "release": "pnpm build && pnpm changeset publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/udecode/skiller.git"
+  },
+  "keywords": [
+    "ai",
+    "developer-tools",
+    "copilot",
+    "codex",
+    "claude",
+    "cursor",
+    "aider",
+    "config",
+    "rules",
+    "automation"
+  ],
+  "author": "Eleanor Berger",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/udecode/skiller/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "skiller": "dist/cli/index.js"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "2.29.8",
+    "@eslint/js": "^9.39.1",
+    "@types/iarna__toml": "^2.0.5",
+    "@types/jest": "^29.5.14",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^24.9.2",
+    "@types/yargs": "^17.0.34",
+    "@typescript-eslint/eslint-plugin": "^8.46.2",
+    "@typescript-eslint/parser": "^8.46.2",
+    "eslint": "^9.38.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "prettier": "^3.6.2",
+    "ts-jest": "^29.4.5",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "js-yaml": "^4.1.0",
+    "yargs": "^18.0.0",
+    "zod": "^4.1.12"
+  }
 }