skiller 0.7.19 → 0.7.20

package/README.md

@@ -60,21 +60,22 @@ A Claude-centric fork of [ruler](https://github.com/intellectronica/ruler) with
 - Reads `.claude/settings.json` `enabledPlugins`
 - 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 `commands/**/*.md` as skills (`SKILL.md`) into agent skills directories (recursive, flattened names)
 - 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 `<pluginName>-<name>` (marketplace only when needed)
-- Tracks plugin-managed skills in a single `.skiller.json` file per agent skills directory
+- If a name conflicts, local skills win and the plugin item is namespaced as `<pluginName>-<name>` (numeric suffix if multiple enabled plugins share the same name)
+- Tracks plugin-managed items in `.claude/.skiller.json` (per project, grouped by agent skills dir)
 - 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
+- Flattens nested commands into dash-separated names (e.g., `workflows/brainstorm.md` → `workflows-brainstorm`)
 - 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.json` file per agent skills directory
+- Tracks project-managed items in `.claude/.skiller.json` (per project, grouped by agent skills dir)
 
 ---
 
@@ -606,10 +607,11 @@ Shared paths are deduplicated — agents sharing the same directory only trigger
 If your project enables Claude Code plugins in `.claude/settings.json`, Skiller also syncs plugin content into agent skills directories on `skiller apply`:
 
 - Plugin `skills/` are copied as skills
-- Plugin `commands/*.md` are converted into skills (`SKILL.md`)
+- Plugin `commands/**/*.md` are converted into skills (`SKILL.md`)
+- Plugin `agents/**/*.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 `<pluginName>-<name>` (marketplace only when needed)
-- Plugin-managed skills are tracked via `.skiller.json` in each agent skills directory
+- If a name conflicts, local skills win and the plugin item is namespaced as `<pluginName>-<name>` (numeric suffix if multiple enabled plugins share the same name)
+- Plugin-managed items are tracked via `.claude/.skiller.json` (per project, grouped by agent skills dir)
 
 ### Skills Directory Structure
 

package/dist/core/ClaudePluginSync.js

@@ -126,36 +126,11 @@ function parsePluginId(pluginId) {
         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) {
+async function resolvePluginMarketplaceRoot(pluginId, claudeDir) {
     const parsed = parsePluginId(pluginId);
     if (!parsed)
         return null;
-    const marketplaceRoot = knownMarketplaceInstallLocations[parsed.marketplaceId] ??
-        path.join(claudeDir, 'plugins', 'marketplaces', parsed.marketplaceId);
+    const marketplaceRoot = path.join(claudeDir, 'plugins', 'marketplaces', parsed.marketplaceId);
     const candidates = [
         path.join(marketplaceRoot, 'plugins', parsed.pluginName),
         path.join(marketplaceRoot, 'external_plugins', parsed.pluginName),
@@ -266,19 +241,31 @@ async function discoverPluginCommandFiles(installPath) {
     const commandsRoot = path.join(installPath, 'commands');
     if (!(await fileExists(commandsRoot)))
         return [];
-    let entries;
-    try {
-        entries = await fs.readdir(commandsRoot, { withFileTypes: true });
-    }
-    catch {
-        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 rel = path.relative(commandsRoot, full).replace(/\\/g, '/');
+            results.push({ rel, file: full });
+        }
     }
-    return entries
-        .filter((e) => e.isFile() && e.name.endsWith('.md'))
-        .map((e) => ({
-        name: path.basename(e.name, '.md'),
-        file: path.join(commandsRoot, e.name),
-    }));
+    await walk(commandsRoot, 0);
+    return results;
 }
 async function discoverPluginAgentFiles(installPath) {
     const agentsRoot = path.join(installPath, 'agents');
@@ -328,8 +315,13 @@ function generateBaseNameFromRelId(relId) {
     const segments = normalized.split('/').filter(Boolean);
     return segments.map(sanitizeId).join('-');
 }
-function generateBaseNameFromCommand(commandName) {
-    return sanitizeId(commandName);
+function generateBaseNameFromCommandRelPath(commandRelPath) {
+    const normalized = commandRelPath.replace(/\\/g, '/');
+    const withoutExt = normalized.endsWith('.md')
+        ? normalized.slice(0, -'.md'.length)
+        : normalized;
+    const segments = withoutExt.split('/').filter(Boolean);
+    return segments.map(sanitizeId).join('-');
 }
 function pluginBaseNamespacePrefix(pluginId) {
     const parsed = parsePluginId(pluginId);
@@ -338,19 +330,25 @@ function pluginBaseNamespacePrefix(pluginId) {
     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();
+    const pluginIdsByBase = 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);
+        const base = pluginBaseNamespacePrefix(pluginId);
+        const bucket = pluginIdsByBase.get(base) ?? [];
+        bucket.push(pluginId);
+        pluginIdsByBase.set(base, bucket);
+    }
+    for (const [base, ids] of pluginIdsByBase.entries()) {
+        ids.sort((a, b) => a.localeCompare(b));
+        if (ids.length === 1) {
+            out.set(ids[0], base);
+            continue;
+        }
+        // If multiple enabled plugins share the same plugin name, disambiguate
+        // without including the marketplace in the folder name.
+        ids.forEach((id, idx) => {
+            out.set(id, idx === 0 ? base : `${base}-${idx + 1}`);
+        });
     }
     return out;
 }
@@ -395,8 +393,8 @@ async function removeLegacyMarkerFile(dir, dryRun) {
         // ignore
     }
 }
-async function loadManagedEntries(targetSkillsDir, dryRun) {
-    const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir);
+async function loadManagedEntries(projectRoot, targetSkillsDir, dryRun) {
+    const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir);
     const pluginEntries = [];
     const otherEntries = [];
     for (const entry of allEntries) {
@@ -501,7 +499,12 @@ async function discoverLocalCommandNames(projectRoot) {
             }
             if (!entry.isFile() || !entry.name.endsWith('.md'))
                 continue;
-            names.add(sanitizeId(path.basename(entry.name, '.md')));
+            const rel = path.relative(localCommandsDir, full).replace(/\\/g, '/');
+            const withoutExt = rel.endsWith('.md')
+                ? rel.slice(0, -'.md'.length)
+                : rel;
+            const segments = withoutExt.split('/').filter(Boolean);
+            names.add(segments.map(sanitizeId).join('-'));
         }
     }
     await walk(localCommandsDir, 0);
@@ -608,7 +611,6 @@ 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);
@@ -620,10 +622,16 @@ async function syncClaudePluginsToSkillsDirs(args) {
     const resolvedSources = [];
     const unresolvedEnabled = new Set();
     for (const pluginId of enabledPlugins) {
-        const pluginRoot = await resolvePluginMarketplaceRoot(pluginId, claudeDir, knownMarketplaceInstallLocations);
+        const pluginRoot = await resolvePluginMarketplaceRoot(pluginId, claudeDir);
         if (!pluginRoot) {
             unresolvedEnabled.add(pluginId);
-            (0, constants_1.logWarn)(`[plugins] Enabled plugin not installed: ${pluginId}`, dryRun);
+            const hasIndexEntry = Boolean(index?.plugins?.[pluginId]?.length);
+            if (hasIndexEntry) {
+                (0, constants_1.logVerboseInfo)(`[plugins] Enabled plugin has no marketplace content, skipping: ${pluginId}`, verbose, dryRun);
+            }
+            else {
+                (0, constants_1.logWarn)(`[plugins] Enabled plugin not installed: ${pluginId}`, dryRun);
+            }
             continue;
         }
         const resolved = index
@@ -653,8 +661,8 @@ async function syncClaudePluginsToSkillsDirs(args) {
         }
         const commandFiles = await discoverPluginCommandFiles(plugin.pluginRoot);
         for (const c of commandFiles) {
-            const baseName = generateBaseNameFromCommand(c.name);
-            const sourceRelPath = `commands/${path.basename(c.file)}`;
+            const baseName = generateBaseNameFromCommandRelPath(c.rel);
+            const sourceRelPath = `commands/${c.rel}`;
             expectedItems.push({
                 itemKey: makeItemKey(plugin.pluginId, 'command', sourceRelPath),
                 pluginId: plugin.pluginId,
@@ -696,7 +704,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
         let managedEntries = [];
         let otherEntries = [];
         if (targetExists) {
-            const loaded = await loadManagedEntries(targetSkillsDir, dryRun);
+            const loaded = await loadManagedEntries(projectRoot, targetSkillsDir, dryRun);
             managedEntries = loaded.pluginEntries;
             otherEntries = loaded.otherEntries;
         }
@@ -859,6 +867,6 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 destRelPath: item.destRelPath,
             });
         }
-        await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(projectRoot, targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
     }
 }

package/dist/core/ClaudeProjectSync.js

@@ -85,7 +85,14 @@ async function discoverCommandFiles(projectRoot) {
             }
             if (!entry.isFile() || !entry.name.endsWith('.md'))
                 continue;
-            const name = sanitizeId(path.basename(entry.name, '.md'));
+            const relFromCommands = path
+                .relative(commandsRoot, full)
+                .replace(/\\/g, '/');
+            const withoutExt = relFromCommands.endsWith('.md')
+                ? relFromCommands.slice(0, -'.md'.length)
+                : relFromCommands;
+            const segments = withoutExt.split('/').filter(Boolean);
+            const name = segments.map(sanitizeId).join('-');
             const rel = path.relative(projectRoot, full).replace(/\\/g, '/');
             results.push({ name, file: full, rel });
         }
@@ -164,9 +171,9 @@ async function writeMarkdownAsSkill(srcPath, destDir, generatedName, kindLabel,
         return;
     await fs.writeFile(path.join(destDir, 'SKILL.md'), next, 'utf8');
 }
-async function readPluginManagedDestNames(targetSkillsDir) {
+async function readPluginManagedDestNames(projectRoot, targetSkillsDir) {
     const names = new Set();
-    for (const entry of await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir)) {
+    for (const entry of await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir)) {
         if ((0, SkillsManifest_1.isPluginManifestEntry)(entry)) {
             names.add(entry.destRelPath);
         }
@@ -262,7 +269,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
         const managedEntries = [];
         const otherEntries = [];
         if (targetExists) {
-            const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir);
+            const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir);
             for (const entry of allEntries) {
                 if ((0, SkillsManifest_1.isClaudeManifestEntry)(entry)) {
                     managedEntries.push(entry);
@@ -278,7 +285,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
         }
         const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
         const pluginManagedDest = targetExists
-            ? await readPluginManagedDestNames(targetSkillsDir)
+            ? await readPluginManagedDestNames(projectRoot, targetSkillsDir)
             : new Set();
         const reserved = new Set(localSkillNames);
         if (targetExists) {
@@ -395,6 +402,6 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
                 destRelPath: item.destRelPath,
             });
         }
-        await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(projectRoot, targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
     }
 }

package/dist/core/SkillsManifest.js

@@ -41,6 +41,8 @@ exports.writeSkillsManifestEntries = writeSkillsManifestEntries;
 exports.listSkillDirectories = listSkillDirectories;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+// Project-level manifest (stored in `.claude/.skiller.json`) that tracks what
+// Skiller installed into each target agent skills directory for this project.
 exports.SKILLS_MANIFEST_FILENAME = '.skiller.json';
 exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME = '.skiller-skills.json';
 exports.LEGACY_PLUGIN_MANIFEST_FILENAME = '.skiller-plugins.json';
@@ -137,6 +139,37 @@ function parseUnifiedEntries(raw) {
     }
     return entries;
 }
+function normalizePathForKey(p) {
+    return path.resolve(p).replace(/\\/g, '/');
+}
+function computeTargetKey(projectRoot, targetSkillsDir) {
+    const resolvedProjectRoot = path.resolve(projectRoot);
+    const resolvedTarget = path.resolve(targetSkillsDir);
+    if (resolvedTarget === resolvedProjectRoot)
+        return '.';
+    if (resolvedTarget.startsWith(resolvedProjectRoot + path.sep)) {
+        return path
+            .relative(resolvedProjectRoot, resolvedTarget)
+            .replace(/\\/g, '/');
+    }
+    return normalizePathForKey(resolvedTarget);
+}
+function parseProjectTargets(raw) {
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const obj = raw;
+    if (!obj.targets || typeof obj.targets !== 'object')
+        return {};
+    const targetsObj = obj.targets;
+    const out = {};
+    for (const [targetKey, rawEntries] of Object.entries(targetsObj)) {
+        // Stored as an array of entries per target.
+        if (!Array.isArray(rawEntries))
+            continue;
+        out[targetKey] = normalizeEntries(parseUnifiedEntries({ entries: rawEntries }));
+    }
+    return out;
+}
 function parseLegacyPluginEntries(raw) {
     if (!raw || typeof raw !== 'object')
         return [];
@@ -197,11 +230,11 @@ function parseLegacyClaudeEntries(raw) {
     }
     return entries;
 }
-async function loadSkillsManifestEntries(targetSkillsDir) {
-    const manifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
-    if (await fileExists(manifestPath)) {
+async function loadLegacyTargetSkillsManifestEntries(targetSkillsDir) {
+    const legacyManifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
+    if (await fileExists(legacyManifestPath)) {
         try {
-            const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+            const raw = JSON.parse(await fs.readFile(legacyManifestPath, 'utf8'));
             return normalizeEntries(parseUnifiedEntries(raw));
         }
         catch {
@@ -243,32 +276,78 @@ async function loadSkillsManifestEntries(targetSkillsDir) {
     }
     return normalizeEntries(merged);
 }
-async function writeSkillsManifestEntries(targetSkillsDir, entries, dryRun) {
-    const manifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
-    const legacyUnifiedPath = path.join(targetSkillsDir, exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME);
-    const legacyPluginPath = path.join(targetSkillsDir, exports.LEGACY_PLUGIN_MANIFEST_FILENAME);
-    const legacyClaudePath = path.join(targetSkillsDir, exports.LEGACY_CLAUDE_MANIFEST_FILENAME);
+async function loadSkillsManifestEntries(projectRoot, targetSkillsDir) {
+    const projectClaudeDir = path.join(projectRoot, '.claude');
+    const projectManifestPath = path.join(projectClaudeDir, exports.SKILLS_MANIFEST_FILENAME);
+    const preferredTargetKey = computeTargetKey(projectRoot, targetSkillsDir);
+    const absoluteTargetKey = normalizePathForKey(targetSkillsDir);
+    if (await fileExists(projectManifestPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(projectManifestPath, 'utf8'));
+            const targets = parseProjectTargets(raw);
+            const entries = targets[preferredTargetKey] ?? targets[absoluteTargetKey] ?? [];
+            return normalizeEntries(entries);
+        }
+        catch {
+            return [];
+        }
+    }
+    // Legacy migration: prior versions stored manifests in the target skills dir.
+    return await loadLegacyTargetSkillsManifestEntries(targetSkillsDir);
+}
+async function writeSkillsManifestEntries(projectRoot, targetSkillsDir, entries, dryRun) {
     const normalized = normalizeEntries(entries);
+    const projectClaudeDir = path.join(projectRoot, '.claude');
+    const projectManifestPath = path.join(projectClaudeDir, exports.SKILLS_MANIFEST_FILENAME);
+    const preferredTargetKey = computeTargetKey(projectRoot, targetSkillsDir);
+    const absoluteTargetKey = normalizePathForKey(targetSkillsDir);
+    let existingTargets = {};
+    if (await fileExists(projectManifestPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(projectManifestPath, 'utf8'));
+            existingTargets = parseProjectTargets(raw);
+        }
+        catch {
+            existingTargets = {};
+        }
+    }
     if (normalized.length === 0) {
-        if (dryRun)
-            return;
-        await Promise.allSettled([
-            fs.unlink(manifestPath),
-            fs.unlink(legacyUnifiedPath),
-            fs.unlink(legacyPluginPath),
-            fs.unlink(legacyClaudePath),
-        ]);
-        return;
+        delete existingTargets[preferredTargetKey];
+        if (preferredTargetKey !== absoluteTargetKey) {
+            delete existingTargets[absoluteTargetKey];
+        }
+    }
+    else {
+        existingTargets[preferredTargetKey] = normalized;
+        if (preferredTargetKey !== absoluteTargetKey) {
+            delete existingTargets[absoluteTargetKey];
+        }
     }
-    const manifest = {
-        version: exports.SKILLS_MANIFEST_VERSION,
-        entries: normalized,
-    };
     if (dryRun)
         return;
-    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
-    // Clean up legacy manifests once unified is written.
+    // Ensure `.claude` exists since the manifest lives there.
+    await fs.mkdir(projectClaudeDir, { recursive: true });
+    const targetKeys = Object.keys(existingTargets).sort((a, b) => a.localeCompare(b));
+    if (targetKeys.length === 0) {
+        await Promise.allSettled([fs.unlink(projectManifestPath)]);
+    }
+    else {
+        const nextTargets = {};
+        for (const key of targetKeys)
+            nextTargets[key] = existingTargets[key];
+        const manifest = {
+            version: exports.SKILLS_MANIFEST_VERSION,
+            targets: nextTargets,
+        };
+        await fs.writeFile(projectManifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    }
+    // Remove legacy per-target manifests so users see a single `.claude/.skiller.json`.
+    const legacyManifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
+    const legacyUnifiedPath = path.join(targetSkillsDir, exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME);
+    const legacyPluginPath = path.join(targetSkillsDir, exports.LEGACY_PLUGIN_MANIFEST_FILENAME);
+    const legacyClaudePath = path.join(targetSkillsDir, exports.LEGACY_CLAUDE_MANIFEST_FILENAME);
     await Promise.allSettled([
+        fs.unlink(legacyManifestPath),
         fs.unlink(legacyUnifiedPath),
         fs.unlink(legacyPluginPath),
         fs.unlink(legacyClaudePath),

package/package.json

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