skiller 0.9.3 → 0.9.5

package/dist/cli/handlers.js

@@ -86,6 +86,88 @@ 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 promptLine(message) {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -323,13 +405,20 @@ async function migrateClaudePluginsHandler(argv) {
             console.log('[skiller] Run again with --execute to install the resolved repos through skills.');
             return;
         }
-        if (plan.unresolved.length > 0) {
-            throw new Error(`Cannot execute migration until all plugins resolve:\n${plan.unresolved.map((entry) => `- ${entry.pluginId}: ${entry.reason}`).join('\n')}`);
+        if (plan.installs.length === 0 && plan.unresolved.length > 0) {
+            throw new Error(`Cannot execute migration because no installable plugin repos were found:\n${plan.unresolved.map((entry) => `- ${entry.pluginId}: ${entry.reason}`).join('\n')}`);
         }
         for (const install of plan.installs) {
             await (0, skills_cli_1.runSkillsCli)(projectRoot, buildClaudePluginMigrationArgs(install.source));
         }
-        console.log('[skiller] Claude plugin repo migration completed. Remove the plugin entries from .claude/settings.json, then rerun skiller apply.');
+        await cleanupLegacyClaudePluginState(projectRoot, [
+            ...plan.installs.flatMap((install) => install.pluginIds),
+            ...plan.unresolved.map((entry) => entry.pluginId),
+        ]);
+        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. 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/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.3",
+  "version": "0.9.5",
   "description": "Skiller — apply the same rules to all coding agents",
   "main": "dist/lib.js",
   "publishConfig": {