skiller 0.9.4 → 0.9.6

package/dist/cli/handlers.js

@@ -71,6 +71,15 @@ async function executeSkillsWrapper(projectRoot, args) {
 function buildClaudePluginMigrationArgs(source) {
     return ['add', source, '--agent', 'universal', '--skill', '*', '-y'];
 }
+function resolveRegistryMatchSource(match) {
+    if (match.source)
+        return match.source;
+    const parts = match.slug.split('/').filter(Boolean);
+    if (parts.length >= 2) {
+        return `${parts[0]}/${parts[1]}`;
+    }
+    return match.slug;
+}
 function formatInstalls(count) {
     if (!count || count <= 0)
         return '0 installs';
@@ -86,6 +95,116 @@ function formatMatch(match) {
     const source = match.source || match.slug;
     return `${source}@${match.name} (${formatInstalls(match.installs)})`;
 }
+async function readJsonObject(filePath) {
+    try {
+        const raw = JSON.parse(await fs.readFile(filePath, 'utf8'));
+        return raw && typeof raw === 'object'
+            ? raw
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function cleanupLegacyClaudePluginState(projectRoot, pluginIds) {
+    const pluginIdSet = new Set(pluginIds);
+    if (pluginIdSet.size === 0)
+        return;
+    const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+    const settings = await readJsonObject(settingsPath);
+    if (settings) {
+        const enabledPlugins = settings.enabledPlugins;
+        if (enabledPlugins && typeof enabledPlugins === 'object') {
+            const nextEnabledPlugins = Object.fromEntries(Object.entries(enabledPlugins).filter(([pluginId]) => !pluginIdSet.has(pluginId)));
+            if (Object.keys(nextEnabledPlugins).length !==
+                Object.keys(enabledPlugins).length) {
+                if (Object.keys(nextEnabledPlugins).length === 0) {
+                    delete settings.enabledPlugins;
+                }
+                else {
+                    settings.enabledPlugins = nextEnabledPlugins;
+                }
+                await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+            }
+        }
+    }
+    for (const manifestPath of [
+        path.join(projectRoot, '.agents', '.skiller.json'),
+        path.join(projectRoot, '.claude', '.skiller.json'),
+    ]) {
+        const manifest = await readJsonObject(manifestPath);
+        if (!manifest)
+            continue;
+        const targets = manifest.targets;
+        if (!targets || typeof targets !== 'object')
+            continue;
+        let changed = false;
+        const nextTargets = {};
+        for (const [targetKey, rawEntries] of Object.entries(targets)) {
+            if (!Array.isArray(rawEntries)) {
+                nextTargets[targetKey] = rawEntries;
+                continue;
+            }
+            const filteredEntries = rawEntries.filter((entry) => {
+                if (!entry || typeof entry !== 'object')
+                    return true;
+                const sourceType = entry.sourceType;
+                const pluginId = entry.pluginId;
+                if (sourceType !== 'plugin' || typeof pluginId !== 'string') {
+                    return true;
+                }
+                return !pluginIdSet.has(pluginId);
+            });
+            if (filteredEntries.length !== rawEntries.length) {
+                changed = true;
+            }
+            if (filteredEntries.length > 0) {
+                nextTargets[targetKey] = filteredEntries;
+            }
+            else {
+                changed = true;
+            }
+        }
+        if (!changed)
+            continue;
+        manifest.targets = nextTargets;
+        const localSkills = manifest.localSkills;
+        const hasLocalSkills = Array.isArray(localSkills) && localSkills.length > 0;
+        if (Object.keys(nextTargets).length === 0 && !hasLocalSkills) {
+            await fs.rm(manifestPath, { force: true });
+            continue;
+        }
+        await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    }
+}
+async function cleanupMigratedPluginAuxiliaryRules(projectRoot, sources) {
+    const candidateRuleNames = await (0, ClaudePluginMigration_1.listClaudePluginAuxiliaryRuleNames)(sources);
+    if (candidateRuleNames.length === 0)
+        return [];
+    const sourceSet = new Set(sources);
+    const plan = await (0, RulesToSkillsMigration_1.planRulesToSkillsMigration)(projectRoot, candidateRuleNames);
+    const removable = new Set(plan.unmatched);
+    for (const candidate of plan.candidates) {
+        const exactMatchSources = candidate.matches.map(resolveRegistryMatchSource);
+        if (exactMatchSources.length === 0 ||
+            exactMatchSources.every((source) => sourceSet.has(source))) {
+            removable.add(candidate.ruleName);
+        }
+    }
+    const removed = [...removable].sort((a, b) => a.localeCompare(b));
+    for (const ruleName of removed) {
+        await (0, RulesToSkillsMigration_1.removeLocalRuleReplacementState)(projectRoot, ruleName, false);
+        await fs.rm(path.join(projectRoot, '.agents', 'skills', ruleName), {
+            force: true,
+            recursive: true,
+        });
+        await fs.rm(path.join(projectRoot, '.claude', 'skills', ruleName), {
+            force: true,
+            recursive: true,
+        });
+    }
+    return removed;
+}
 async function promptLine(message) {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -329,10 +448,18 @@ async function migrateClaudePluginsHandler(argv) {
         for (const install of plan.installs) {
             await (0, skills_cli_1.runSkillsCli)(projectRoot, buildClaudePluginMigrationArgs(install.source));
         }
+        await cleanupLegacyClaudePluginState(projectRoot, [
+            ...plan.installs.flatMap((install) => install.pluginIds),
+            ...plan.unresolved.map((entry) => entry.pluginId),
+        ]);
+        const removedAuxiliaryRules = await cleanupMigratedPluginAuxiliaryRules(projectRoot, plan.installs.map((install) => install.source));
+        if (removedAuxiliaryRules.length > 0) {
+            console.log(`[skiller] Removed stale plugin-derived local rules:\n${removedAuxiliaryRules.map((name) => `- ${name}`).join('\n')}`);
+        }
         if (plan.unresolved.length > 0) {
             console.log(`[skiller] Skipped unresolved plugins:\n${plan.unresolved.map((entry) => `- ${entry.pluginId}: ${entry.reason}`).join('\n')}`);
         }
-        console.log('[skiller] Claude plugin repo migration completed. Remove the plugin entries from .claude/settings.json, then rerun skiller apply.');
+        console.log('[skiller] Claude plugin repo migration completed. Legacy Claude plugin entries were removed from settings/manifests; rerun skiller apply.');
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);

package/dist/core/ClaudePluginMigration.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.listClaudePluginAuxiliaryRuleNames = listClaudePluginAuxiliaryRuleNames;
 exports.planClaudePluginSkillsMigration = planClaudePluginSkillsMigration;
 const fs = __importStar(require("fs/promises"));
 const os = __importStar(require("os"));
@@ -86,6 +87,20 @@ function normalizeCloneSource(source) {
     }
     return source;
 }
+function normalizeSkillNameForDir(value) {
+    return value.replace(/:/g, '-').trim();
+}
+function extractAuxiliarySkillNames(skillMd) {
+    const names = new Set();
+    const pattern = /\b[a-z0-9-]+:[a-z0-9-]+:([a-z0-9-]+)\b/g;
+    for (const match of skillMd.toLowerCase().matchAll(pattern)) {
+        const candidate = match[1]?.trim();
+        if (!candidate || !/[a-z]/.test(candidate))
+            continue;
+        names.add(candidate);
+    }
+    return [...names];
+}
 function formatInspectionError(source, err) {
     if (typeof err === 'object' && err !== null) {
         const stderr = 'stderr' in err ? err.stderr : '';
@@ -112,18 +127,30 @@ async function inspectSkillsInstallSource(source) {
             repoDir,
         ]);
         const { skills } = await (0, SkillsUtils_1.walkSkillsTree)(repoDir);
+        const publishedSkillNames = new Set();
+        const auxiliarySkillNames = new Set();
         for (const skill of skills) {
             try {
                 const skillMd = await fs.readFile(path.join(skill.path, 'SKILL.md'), 'utf8');
                 const { frontmatter } = (0, FrontmatterParser_1.parseFrontmatter)(skillMd);
                 if (frontmatter?.name && frontmatter.description) {
-                    return { installable: true };
+                    publishedSkillNames.add(normalizeSkillNameForDir(String(frontmatter.name)));
+                    for (const auxiliaryName of extractAuxiliarySkillNames(skillMd)) {
+                        auxiliarySkillNames.add(auxiliaryName);
+                    }
                 }
             }
             catch {
                 // Keep scanning. One malformed skill should not hide valid siblings.
             }
         }
+        if (publishedSkillNames.size > 0) {
+            return {
+                installable: true,
+                auxiliarySkillNames: [...auxiliarySkillNames].sort((a, b) => a.localeCompare(b)),
+                publishedSkillNames: [...publishedSkillNames].sort((a, b) => a.localeCompare(b)),
+            };
+        }
         return {
             installable: false,
             reason: `Resolved source ${source} has no valid SKILL.md files with name and description`,
@@ -139,6 +166,23 @@ async function inspectSkillsInstallSource(source) {
         await fs.rm(tmpDir, { recursive: true, force: true });
     }
 }
+async function listClaudePluginAuxiliaryRuleNames(sources, options = {}) {
+    const inspectSource = options.inspectSource ?? inspectSkillsInstallSource;
+    const auxiliarySkillNames = new Set();
+    for (const source of [...new Set(sources)].sort((a, b) => a.localeCompare(b))) {
+        const inspection = await inspectSource(source);
+        if (!inspection.installable)
+            continue;
+        const published = new Set((inspection.publishedSkillNames ?? []).map(normalizeSkillNameForDir));
+        for (const auxiliaryName of inspection.auxiliarySkillNames ?? []) {
+            const normalized = normalizeSkillNameForDir(auxiliaryName);
+            if (!normalized || published.has(normalized))
+                continue;
+            auxiliarySkillNames.add(normalized);
+        }
+    }
+    return [...auxiliarySkillNames].sort((a, b) => a.localeCompare(b));
+}
 async function readEnabledPluginIds(projectRoot) {
     const settingsPath = path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR, 'settings.json');
     const raw = await readJsonFile(settingsPath);

package/dist/core/SkillOwnership.js

@@ -218,6 +218,27 @@ async function planDirectoryMigration(sourceDir, destinationDir, plannedWrites,
         deletePaths.add(sourceDir);
     }
 }
+async function planLegacySkillsMigration(legacySkillsDir, canonicalSkillsDir, plannedWrites, deletePaths, conflicts) {
+    if (!(await pathExists(legacySkillsDir)))
+        return;
+    const entries = await fs.readdir(legacySkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const sourceDir = path.join(legacySkillsDir, entry.name);
+        const destinationDir = path.join(canonicalSkillsDir, entry.name);
+        if (await pathExists(destinationDir)) {
+            // Canonical .agents/skills already owns this name now. Legacy
+            // .claude/skills duplicates are stale migration debris.
+            deletePaths.add(sourceDir);
+            continue;
+        }
+        await planDirectoryMigration(sourceDir, destinationDir, plannedWrites, deletePaths, conflicts);
+    }
+    if (conflicts.length === 0) {
+        deletePaths.add(legacySkillsDir);
+    }
+}
 async function findRuleSkillFolders(dir) {
     const folders = [];
     const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -395,7 +416,7 @@ async function migrateLegacyProjectState(projectRoot, dryRun) {
         }
     }
     await planFileMigration(path.join(legacyDir, project_paths_1.PROJECT_AGENTS_FILE), path.join(canonicalDir, project_paths_1.PROJECT_AGENTS_FILE), plannedWrites, deletePaths, conflicts);
-    await planDirectoryMigration(path.join(legacyDir, 'skills'), canonicalSkillsDir, plannedWrites, deletePaths, conflicts);
+    await planLegacySkillsMigration(path.join(legacyDir, 'skills'), canonicalSkillsDir, plannedWrites, deletePaths, conflicts);
     await planLegacyRulesMigration(path.join(legacyDir, 'rules'), canonicalRulesDir, canonicalSkillsDir, plannedWrites, deletePaths, conflicts);
     if (conflicts.length > 0) {
         throw new Error(`Legacy .claude migration conflicts:\n- ${conflicts.join('\n- ')}`);

package/package.json

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