skiller 0.7.17 → 0.7.19

package/README.md

@@ -53,15 +53,17 @@ A Claude-centric fork of [ruler](https://github.com/intellectronica/ruler) with
 - Shared paths are deduplicated (Claude/Copilot/Kilo share `.claude/skills`, Goose/Amp share `.agents/skills`)
 - Agent skills directories are auto-added to `.gitignore` (excluding `.claude/skills`)
 - Validates skill structure — warns on missing `SKILL.md`
+- Flattens nested skills into dash-separated names for agent skills dirs (e.g., `workflows/lfg` → `workflows-lfg`)
 
 ## 9. Claude Code Plugins → Skills
 
 - Reads `.claude/settings.json` `enabledPlugins`
-- Syncs enabled plugin `skills/` into agent skills directories on `skiller apply`
+- Reads plugin content from `~/.claude/plugins/marketplaces` (never from `cache/`)
+- Syncs enabled plugin `skills/` into agent skills directories on `skiller apply` (recursive, flattened names)
 - Syncs enabled plugin `commands/*.md` as skills (`SKILL.md`) into agent skills directories
 - 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>`
+- If a name conflicts, local skills win and the plugin skill is namespaced as `<pluginName>-<name>` (marketplace only when needed)
 - Tracks plugin-managed skills in a single `.skiller.json` file per agent skills directory
 - Removes stale plugin skills when plugins are disabled
 
@@ -606,7 +608,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 `<pluginName>-<name>` (marketplace only when needed)
 - Plugin-managed skills are tracked via `.skiller.json` in each agent skills directory
 
 ### Skills Directory Structure

package/dist/core/ClaudePluginSync.js

@@ -71,6 +71,14 @@ async function fileExists(p) {
         return false;
     }
 }
+async function dirExists(p) {
+    try {
+        return (await fs.stat(p)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 function makeItemKey(pluginId, sourceKind, sourceRelPath) {
     return `${pluginId}::${sourceKind}::${sourceRelPath}`;
 }
@@ -107,6 +115,59 @@ async function readInstalledPluginsIndex(claudeDir) {
         return null;
     }
 }
+function parsePluginId(pluginId) {
+    // `pluginId` format is typically `<pluginName>@<marketplaceId>`.
+    // Split by the last `@` so scoped names like `@org/foo@market` work.
+    const at = pluginId.lastIndexOf('@');
+    if (at <= 0 || at === pluginId.length - 1)
+        return null;
+    return {
+        pluginName: pluginId.slice(0, at),
+        marketplaceId: pluginId.slice(at + 1),
+    };
+}
+async function readKnownMarketplaceInstallLocations(claudeDir) {
+    const knownPath = path.join(claudeDir, 'plugins', 'known_marketplaces.json');
+    let raw;
+    try {
+        raw = JSON.parse(await fs.readFile(knownPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const obj = raw;
+    const out = {};
+    for (const [marketplaceId, marketplace] of Object.entries(obj)) {
+        if (!marketplace || typeof marketplace !== 'object')
+            continue;
+        const installLocation = marketplace
+            .installLocation;
+        if (typeof installLocation !== 'string' || installLocation.trim() === '')
+            continue;
+        out[marketplaceId] = installLocation;
+    }
+    return out;
+}
+async function resolvePluginMarketplaceRoot(pluginId, claudeDir, knownMarketplaceInstallLocations) {
+    const parsed = parsePluginId(pluginId);
+    if (!parsed)
+        return null;
+    const marketplaceRoot = knownMarketplaceInstallLocations[parsed.marketplaceId] ??
+        path.join(claudeDir, 'plugins', 'marketplaces', parsed.marketplaceId);
+    const candidates = [
+        path.join(marketplaceRoot, 'plugins', parsed.pluginName),
+        path.join(marketplaceRoot, 'external_plugins', parsed.pluginName),
+        path.join(marketplaceRoot, '.claude-plugin', 'plugins', parsed.pluginName),
+        path.join(marketplaceRoot, '.claude-plugin', 'external_plugins', parsed.pluginName),
+    ];
+    for (const candidate of candidates) {
+        if (await dirExists(candidate))
+            return candidate;
+    }
+    return null;
+}
 function resolvePluginInstall(pluginId, projectRoot, index) {
     const entries = index.plugins?.[pluginId];
     if (!entries || !Array.isArray(entries) || entries.length === 0)
@@ -265,13 +326,33 @@ async function discoverPluginAgentFiles(installPath) {
 function generateBaseNameFromRelId(relId) {
     const normalized = relId.replace(/\\/g, '/');
     const segments = normalized.split('/').filter(Boolean);
-    return segments.map(sanitizeId).join('__');
+    return segments.map(sanitizeId).join('-');
 }
 function generateBaseNameFromCommand(commandName) {
     return sanitizeId(commandName);
 }
-function generateNamespacedName(pluginId, baseName) {
-    return `${sanitizeId(pluginId)}-${baseName}`;
+function pluginBaseNamespacePrefix(pluginId) {
+    const parsed = parsePluginId(pluginId);
+    if (parsed)
+        return sanitizeId(parsed.pluginName);
+    return sanitizeId(pluginId);
+}
+function computePluginNamespacePrefixes(pluginIds) {
+    const basePrefixByPluginId = new Map();
+    const counts = new Map();
+    for (const pluginId of pluginIds) {
+        const base = pluginBaseNamespacePrefix(pluginId);
+        basePrefixByPluginId.set(pluginId, base);
+        counts.set(base, (counts.get(base) ?? 0) + 1);
+    }
+    const out = new Map();
+    for (const pluginId of pluginIds) {
+        const base = basePrefixByPluginId.get(pluginId) ?? sanitizeId(pluginId);
+        // If multiple enabled plugins share the same pluginName, fall back to the
+        // full pluginId for uniqueness (includes marketplace).
+        out.set(pluginId, (counts.get(base) ?? 0) > 1 ? sanitizeId(pluginId) : base);
+    }
+    return out;
 }
 async function readLegacyMarkerFile(dir) {
     const markerPath = path.join(dir, LEGACY_MARKER_FILENAME);
@@ -378,7 +459,14 @@ async function discoverLocalSkillNames(projectRoot) {
         }
         const hasSkillMd = entries.some((e) => e.isFile() && e.name === 'SKILL.md');
         if (hasSkillMd) {
-            names.add(path.basename(current));
+            const rel = path.relative(localSkillsDir, current).replace(/\\/g, '/');
+            const segments = rel.split('/').filter(Boolean);
+            if (segments.length > 0) {
+                names.add(segments.map(sanitizeId).join('-'));
+            }
+            else {
+                names.add(sanitizeId(path.basename(current)));
+            }
             return;
         }
         for (const entry of entries) {
@@ -520,6 +608,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
     }
     const claudeDir = path.join(getUserHomeDir(), '.claude');
     const index = await readInstalledPluginsIndex(claudeDir);
+    const knownMarketplaceInstallLocations = await readKnownMarketplaceInstallLocations(claudeDir);
     const localSkillNames = await discoverLocalSkillNames(projectRoot);
     const localCommandNames = await discoverLocalCommandNames(projectRoot);
     const localAgentNames = await discoverLocalAgentNames(projectRoot);
@@ -528,66 +617,27 @@ async function syncClaudePluginsToSkillsDirs(args) {
         ...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.
-    if (!index) {
-        for (const targetSkillsDir of targetSkillsDirs) {
-            if (!(await fileExists(targetSkillsDir)))
-                continue;
-            const { pluginEntries: managedEntries, otherEntries } = await loadManagedEntries(targetSkillsDir, dryRun);
-            const nextEntries = [];
-            // Build reserved set (local skills always win).
-            const reserved = new Set(localReservedNames);
-            // Also reserve any existing non-managed directories.
-            const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
-            let dirents = [];
-            try {
-                dirents = await fs.readdir(targetSkillsDir, { withFileTypes: true });
-            }
-            catch {
-                // ignore
-            }
-            for (const d of dirents) {
-                if (!d.isDirectory())
-                    continue;
-                if (!managedDest.has(d.name)) {
-                    reserved.add(d.name);
-                }
-            }
-            for (const entry of managedEntries) {
-                const isEnabled = enabledPlugins.includes(entry.pluginId);
-                if (!isEnabled) {
-                    if (reserved.has(entry.destRelPath)) {
-                        // Local took over the folder name; stop managing it but don't delete.
-                        continue;
-                    }
-                    (0, constants_1.logVerboseInfo)(dryRun
-                        ? `DRY RUN: Would remove stale plugin skill '${entry.destRelPath}' from ${targetSkillsDir}`
-                        : `Removing stale plugin skill '${entry.destRelPath}' from ${targetSkillsDir}`, verbose, dryRun);
-                    await removeDir(path.join(targetSkillsDir, entry.destRelPath), dryRun);
-                    continue;
-                }
-                nextEntries.push(entry);
-            }
-            await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
-        }
-        return;
-    }
-    const resolvedInstalls = [];
+    const resolvedSources = [];
     const unresolvedEnabled = new Set();
     for (const pluginId of enabledPlugins) {
-        const resolved = resolvePluginInstall(pluginId, projectRoot, index);
-        if (!resolved) {
+        const pluginRoot = await resolvePluginMarketplaceRoot(pluginId, claudeDir, knownMarketplaceInstallLocations);
+        if (!pluginRoot) {
             unresolvedEnabled.add(pluginId);
             (0, constants_1.logWarn)(`[plugins] Enabled plugin not installed: ${pluginId}`, dryRun);
             continue;
         }
-        resolvedInstalls.push(resolved);
+        const resolved = index
+            ? resolvePluginInstall(pluginId, projectRoot, index)
+            : null;
+        resolvedSources.push({
+            pluginId,
+            pluginRoot,
+            version: resolved?.version,
+        });
     }
     const expectedItems = [];
-    for (const plugin of resolvedInstalls) {
-        const skillDirs = await discoverPluginSkillDirs(plugin.installPath);
+    for (const plugin of resolvedSources) {
+        const skillDirs = await discoverPluginSkillDirs(plugin.pluginRoot);
         for (const s of skillDirs) {
             const baseName = generateBaseNameFromRelId(s.relId);
             const sourceRelPath = `skills/${s.relId}`;
@@ -601,7 +651,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 baseName,
             });
         }
-        const commandFiles = await discoverPluginCommandFiles(plugin.installPath);
+        const commandFiles = await discoverPluginCommandFiles(plugin.pluginRoot);
         for (const c of commandFiles) {
             const baseName = generateBaseNameFromCommand(c.name);
             const sourceRelPath = `commands/${path.basename(c.file)}`;
@@ -615,7 +665,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 baseName,
             });
         }
-        const agentFiles = await discoverPluginAgentFiles(plugin.installPath);
+        const agentFiles = await discoverPluginAgentFiles(plugin.pluginRoot);
         for (const a of agentFiles) {
             const baseName = sanitizeId(a.name);
             const sourceRelPath = `agents/${a.rel}`;
@@ -635,6 +685,9 @@ async function syncClaudePluginsToSkillsDirs(args) {
         const bk = `${b.baseName}::${b.pluginId}::${b.kind}::${b.sourceRelPath}`;
         return ak.localeCompare(bk);
     });
+    const pluginNamespacePrefixByPluginId = computePluginNamespacePrefixes([
+        ...new Set(resolvedSources.map((p) => p.pluginId)),
+    ]);
     // Sync into each target skills dir.
     for (const targetSkillsDir of targetSkillsDirs) {
         const targetExists = await fileExists(targetSkillsDir);
@@ -679,11 +732,17 @@ 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.
+            const desiredPrefix = pluginNamespacePrefixByPluginId.get(item.pluginId) ??
+                sanitizeId(item.pluginId);
+            // Migration: previous versions used `${pluginId}__${name}`, then
+            // `${pluginId}-${name}`. If we changed the namespace prefix (for example
+            // to omit marketplace), don't preserve the old destination so the item
+            // can be renamed.
             if (prev.startsWith(`${sanitizeId(item.pluginId)}__`))
                 continue;
+            if (prev.startsWith(`${sanitizeId(item.pluginId)}-`) &&
+                desiredPrefix !== sanitizeId(item.pluginId))
+                continue;
             if (taken.has(prev))
                 continue;
             assignedDestByItemKey.set(item.itemKey, prev);
@@ -699,7 +758,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 taken.add(base);
                 continue;
             }
-            const namespacedBase = generateNamespacedName(item.pluginId, base);
+            const namespacedBase = `${pluginNamespacePrefixByPluginId.get(item.pluginId) ?? sanitizeId(item.pluginId)}-${base}`;
             let candidate = namespacedBase;
             let i = 2;
             while (taken.has(candidate)) {

package/dist/core/ClaudeProjectSync.js

@@ -209,7 +209,14 @@ async function discoverLocalSkillNames(projectRoot) {
         }
         const hasSkillMd = entries.some((e) => e.isFile() && e.name === 'SKILL.md');
         if (hasSkillMd) {
-            names.add(path.basename(current));
+            const rel = path.relative(localSkillsDir, current).replace(/\\/g, '/');
+            const segments = rel.split('/').filter(Boolean);
+            if (segments.length > 0) {
+                names.add(segments.map(sanitizeId).join('-'));
+            }
+            else {
+                names.add(sanitizeId(path.basename(current)));
+            }
             return;
         }
         for (const entry of entries) {

package/dist/core/SkillsProcessor.js

@@ -462,6 +462,32 @@ async function discoverSkills(projectRoot, skillerDir) {
 async function copySkillsToAgent(sourceSkillsDir, targetSkillsDir, projectRoot, verbose, dryRun) {
     const warnings = [];
     let copied = 0;
+    function sanitizeId(value) {
+        return value.replace(/[^A-Za-z0-9._-]+/g, '_');
+    }
+    function flattenRelativeSkillPath(relativeSkillPath) {
+        const normalized = relativeSkillPath.replace(/\\/g, '/');
+        const segments = normalized.split('/').filter(Boolean);
+        return segments.map(sanitizeId).join('-');
+    }
+    async function rewriteSkillMdName(skillMdPath, name) {
+        let content;
+        try {
+            content = await fs.readFile(skillMdPath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        const { rawFrontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(content);
+        const fm = rawFrontmatter
+            ? { ...rawFrontmatter }
+            : {};
+        fm.name = name;
+        const next = `---\n${yaml
+            .dump(fm, { lineWidth: -1, noRefs: true })
+            .trim()}\n---\n\n${body}\n`;
+        await fs.writeFile(skillMdPath, next, 'utf8');
+    }
     try {
         await fs.access(sourceSkillsDir);
     }
@@ -471,8 +497,15 @@ async function copySkillsToAgent(sourceSkillsDir, targetSkillsDir, projectRoot,
     }
     // Use walkSkillsTree to discover skills
     const skillsTree = await (0, SkillsUtils_1.walkSkillsTree)(sourceSkillsDir);
+    // Deterministic order so name collision suffixing is stable.
+    const sortedSkills = [...skillsTree.skills].sort((a, b) => {
+        const ar = path.relative(sourceSkillsDir, a.path).replace(/\\/g, '/');
+        const br = path.relative(sourceSkillsDir, b.path).replace(/\\/g, '/');
+        return ar.localeCompare(br);
+    });
+    const taken = new Set();
     // Validate and copy each skill
-    for (const skill of skillsTree.skills) {
+    for (const skill of sortedSkills) {
         // skill.path is absolute, use it directly
         const skillPath = skill.path;
         const skillMdPath = path.join(skillPath, constants_1.SKILL_MD_FILENAME);
@@ -484,11 +517,23 @@ async function copySkillsToAgent(sourceSkillsDir, targetSkillsDir, projectRoot,
             warnings.push(`Skill '${skill.name}' missing required SKILL.md file, skipping`);
             continue;
         }
-        // Copy skill directory to target using relative path
+        // Flatten nested skills into root-level skill folders for other agents:
+        // `category/foo` -> `category-foo`
         const relativeSkillPath = path.relative(sourceSkillsDir, skill.path);
-        const targetSkillPath = path.join(targetSkillsDir, relativeSkillPath);
+        const baseDestName = flattenRelativeSkillPath(relativeSkillPath);
+        let destName = baseDestName;
+        let i = 2;
+        while (taken.has(destName)) {
+            destName = `${baseDestName}-${i++}`;
+        }
+        taken.add(destName);
+        const targetSkillPath = path.join(targetSkillsDir, destName);
         if (!dryRun) {
             await copySkillDirectoryForNonClaudeAgents(skillPath, targetSkillPath, projectRoot, skillPath);
+            const sourceLeafName = path.basename(skillPath);
+            if (destName !== sourceLeafName) {
+                await rewriteSkillMdName(path.join(targetSkillPath, constants_1.SKILL_MD_FILENAME), destName);
+            }
         }
         (0, constants_1.logVerboseInfo)(dryRun
             ? `DRY RUN: Would copy skill '${skill.name}' to ${targetSkillsDir}`

package/package.json

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