skiller 0.8.1 → 0.9.0

package/dist/cli/commands.js

@@ -3,6 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = run;
 const handlers_1 = require("./handlers");
 const index_1 = require("../agents/index");
+function skillsArgsBuilder(y) {
+    return y
+        .option('project-root', {
+        type: 'string',
+        description: 'Project root directory',
+        default: process.cwd(),
+    })
+        .positional('args', {
+        type: 'string',
+        array: true,
+        description: 'Arguments passed through to the local skills CLI',
+    });
+}
 /**
  * Sets up and parses CLI commands.
  */
@@ -74,6 +87,16 @@ async function run() {
             description: 'Enable/disable skills support (experimental, default: enabled)',
         });
     }, handlers_1.applyHandler)
+        .command('add [args..]', 'Run the local skills CLI add command', skillsArgsBuilder, handlers_1.addHandler)
+        .command('remove [args..]', 'Run the local skills CLI remove command', skillsArgsBuilder, handlers_1.removeHandler)
+        .command('list [args..]', 'Run the local skills CLI list command', skillsArgsBuilder, handlers_1.listHandler)
+        .command('find [args..]', 'Run the local skills CLI find command', skillsArgsBuilder, handlers_1.findHandler)
+        .command('check [args..]', 'Run the local skills CLI check command', skillsArgsBuilder, handlers_1.checkHandler)
+        .command('update [args..]', 'Run the local skills CLI update command', skillsArgsBuilder, handlers_1.updateHandler)
+        .command('skills <subcommand> [args..]', 'Pass through an arbitrary command to the local skills CLI', (y) => skillsArgsBuilder(y).positional('subcommand', {
+        type: 'string',
+        description: 'The local skills CLI subcommand to run',
+    }), handlers_1.skillsHandler)
         .command('init', 'Scaffold a .claude directory with default files', (y) => {
         return y
             .option('project-root', {
@@ -87,6 +110,42 @@ async function run() {
             default: false,
         });
     }, handlers_1.initHandler)
+        .command('migrate claude-plugins', 'Plan or execute a one-shot migration from legacy Claude plugins to skills installs', (y) => {
+        return y
+            .option('project-root', {
+            type: 'string',
+            description: 'Project root directory',
+            default: process.cwd(),
+        })
+            .option('execute', {
+            type: 'boolean',
+            description: 'Actually install the resolved repos through the local skills CLI',
+            default: false,
+        });
+    }, handlers_1.migrateClaudePluginsHandler)
+        .command('migrate rules-to-skills [rules..]', 'Detect local .agents/rules .mdc files that already exist on skills.sh and optionally replace them', (y) => {
+        return y
+            .option('project-root', {
+            type: 'string',
+            description: 'Project root directory',
+            default: process.cwd(),
+        })
+            .option('execute', {
+            type: 'boolean',
+            description: 'Actually replace selected local rules after detection',
+            default: false,
+        })
+            .option('yes', {
+            type: 'boolean',
+            description: 'Auto-replace only unambiguous exact matches without prompting',
+            default: false,
+        })
+            .positional('rules', {
+            type: 'string',
+            array: true,
+            description: 'Specific rule names or .mdc files to check (default: all .agents/rules/*.mdc)',
+        });
+    }, handlers_1.migrateRulesToSkillsHandler)
         .command('revert', 'Revert skiller configurations from supported AI agents', (y) => {
         return y
             .option('project-root', {
@@ -120,7 +179,7 @@ async function run() {
         })
             .option('local-only', {
             type: 'boolean',
-            description: 'Only search for local .claude directories, ignore global config',
+            description: 'Only search for local .agents directories, ignore global config',
             default: false,
         });
     }, handlers_1.revertHandler)

package/dist/cli/handlers.js

@@ -35,6 +35,15 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyHandler = applyHandler;
 exports.initHandler = initHandler;
+exports.migrateClaudePluginsHandler = migrateClaudePluginsHandler;
+exports.migrateRulesToSkillsHandler = migrateRulesToSkillsHandler;
+exports.addHandler = addHandler;
+exports.removeHandler = removeHandler;
+exports.listHandler = listHandler;
+exports.findHandler = findHandler;
+exports.checkHandler = checkHandler;
+exports.updateHandler = updateHandler;
+exports.skillsHandler = skillsHandler;
 exports.revertHandler = revertHandler;
 const lib_1 = require("../lib");
 const revert_1 = require("../revert");
@@ -43,7 +52,107 @@ const os = __importStar(require("os"));
 const fs = __importStar(require("fs/promises"));
 const constants_1 = require("../constants");
 const ConfigLoader_1 = require("../core/ConfigLoader");
+const ClaudePluginMigration_1 = require("../core/ClaudePluginMigration");
+const RulesToSkillsMigration_1 = require("../core/RulesToSkillsMigration");
 const agents_1 = require("../agents");
+const skills_cli_1 = require("./skills-cli");
+const project_paths_1 = require("../core/project-paths");
+const readline = __importStar(require("readline/promises"));
+async function executeSkillsWrapper(projectRoot, args) {
+    try {
+        await (0, skills_cli_1.runSkillsCli)(projectRoot, args);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`${constants_1.ERROR_PREFIX} ${message}`);
+        process.exit(1);
+    }
+}
+function buildClaudePluginMigrationArgs(source) {
+    return ['add', source, '--agent', 'universal', '--skill', '*', '-y'];
+}
+function formatInstalls(count) {
+    if (!count || count <= 0)
+        return '0 installs';
+    if (count >= 1000000) {
+        return `${(count / 1000000).toFixed(1).replace(/\.0$/, '')}M installs`;
+    }
+    if (count >= 1000) {
+        return `${(count / 1000).toFixed(1).replace(/\.0$/, '')}K installs`;
+    }
+    return `${count} install${count === 1 ? '' : 's'}`;
+}
+function formatMatch(match) {
+    const source = match.source || match.slug;
+    return `${source}@${match.name} (${formatInstalls(match.installs)})`;
+}
+async function promptLine(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        return (await rl.question(message)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptForReplacement(candidate) {
+    if (candidate.alreadyInstalled) {
+        const answer = await promptLine(`[skiller] '${candidate.ruleName}' is already installed upstream. Remove the local rule copy? [y/N] `);
+        return /^y(es)?$/i.test(answer) ? 'cleanup' : null;
+    }
+    if (candidate.matches.length === 1) {
+        const match = candidate.matches[0];
+        const answer = await promptLine(`[skiller] Replace '${candidate.ruleName}' with ${formatMatch(match)}? [y/N] `);
+        return /^y(es)?$/i.test(answer) ? match : null;
+    }
+    console.log(`[skiller] Multiple exact matches for '${candidate.ruleName}':`);
+    for (const [index, match] of candidate.matches.entries()) {
+        console.log(`  ${index + 1}. ${formatMatch(match)}`);
+    }
+    const answer = await promptLine(`[skiller] Choose 1-${candidate.matches.length} or press Enter to skip: `);
+    if (answer.length === 0)
+        return null;
+    const selectedIndex = Number.parseInt(answer, 10);
+    if (Number.isNaN(selectedIndex) ||
+        selectedIndex < 1 ||
+        selectedIndex > candidate.matches.length) {
+        console.log(`[skiller] Skipping '${candidate.ruleName}' (invalid choice).`);
+        return null;
+    }
+    return candidate.matches[selectedIndex - 1];
+}
+function printRulesToSkillsPlan(plan) {
+    console.log(`[skiller] Scanned ${plan.scannedRules.length} local rule(s) from .agents/rules.`);
+    if (plan.candidates.length > 0) {
+        console.log('[skiller] Exact skills.sh matches:');
+        for (const candidate of plan.candidates) {
+            if (candidate.alreadyInstalled) {
+                console.log(`- ${candidate.ruleName}: already installed upstream; local rule can be removed`);
+                continue;
+            }
+            if (candidate.matches.length === 1) {
+                console.log(`- ${candidate.ruleName}: ${formatMatch(candidate.matches[0])}`);
+                continue;
+            }
+            console.log(`- ${candidate.ruleName}: ${candidate.matches.length} exact matches`);
+            for (const match of candidate.matches) {
+                console.log(`  - ${formatMatch(match)}`);
+            }
+        }
+    }
+    else {
+        console.log('[skiller] No exact skills.sh matches found.');
+    }
+    if (plan.unmatched.length > 0) {
+        console.log(`[skiller] No exact match for: ${plan.unmatched.join(', ')}`);
+    }
+    if (plan.missingRequested.length > 0) {
+        console.log(`[skiller] Requested rules not found: ${plan.missingRequested.join(', ')}`);
+    }
+}
 /**
  * Handler for the 'apply' command.
  */
@@ -125,10 +234,10 @@ async function initHandler(argv) {
     const isGlobal = argv['global'];
     const skillerDir = isGlobal
         ? path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'skiller')
-        : path.join(projectRoot, '.claude');
+        : path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR);
     await fs.mkdir(skillerDir, { recursive: true });
-    const instructionsPath = path.join(skillerDir, constants_1.DEFAULT_RULES_FILENAME); // .claude/AGENTS.md
-    const tomlPath = path.join(skillerDir, 'skiller.toml');
+    const instructionsPath = path.join(skillerDir, constants_1.DEFAULT_RULES_FILENAME);
+    const tomlPath = path.join(skillerDir, project_paths_1.SKILLER_CONFIG_FILE);
     const exists = async (p) => {
         try {
             await fs.access(p);
@@ -146,8 +255,8 @@ async function initHandler(argv) {
 # uncomment and populate the following line. If omitted, all agents are active.
 # default_agents = ["github-copilot", "claude-code"]
 
-# Enable nested rule loading from nested .claude directories
-# When enabled, skiller will search for and process .claude directories throughout the project hierarchy
+# Enable nested rule loading from nested .agents directories
+# When enabled, skiller will search for and process .agents directories throughout the project hierarchy
 # nested = false
 
 # --- Agent Specific Configurations ---
@@ -195,6 +304,132 @@ async function initHandler(argv) {
         console.log(`[skiller] skiller.toml already exists, skipping`);
     }
 }
+async function migrateClaudePluginsHandler(argv) {
+    const projectRoot = argv['project-root'];
+    try {
+        const plan = await (0, ClaudePluginMigration_1.planClaudePluginSkillsMigration)(projectRoot);
+        if (plan.installs.length === 0 && plan.unresolved.length === 0) {
+            console.log('[skiller] No Claude plugin repos found to migrate.');
+            return;
+        }
+        console.log('[skiller] Claude plugin migration plan:');
+        for (const install of plan.installs) {
+            console.log(`- ${install.source} <- ${install.pluginIds.join(', ')} (${install.strategy})`);
+        }
+        for (const unresolved of plan.unresolved) {
+            console.log(`- unresolved ${unresolved.pluginId}: ${unresolved.reason}`);
+        }
+        if (!argv.execute) {
+            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')}`);
+        }
+        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.');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`${constants_1.ERROR_PREFIX} ${message}`);
+        process.exit(1);
+    }
+}
+async function migrateRulesToSkillsHandler(argv) {
+    const projectRoot = argv['project-root'];
+    try {
+        const plan = await (0, RulesToSkillsMigration_1.planRulesToSkillsMigration)(projectRoot, argv.rules);
+        printRulesToSkillsPlan(plan);
+        if (!argv.execute) {
+            console.log('[skiller] Run again with --execute to replace interactively, or --execute --yes to auto-replace unambiguous matches.');
+            return;
+        }
+        if (!argv.yes && !process.stdin.isTTY) {
+            throw new Error('Interactive replacement requires a TTY. Re-run with --yes to auto-replace only unambiguous matches.');
+        }
+        let replacedCount = 0;
+        for (const candidate of plan.candidates) {
+            let selection = null;
+            if (argv.yes) {
+                if (candidate.alreadyInstalled) {
+                    selection = 'cleanup';
+                }
+                else if (candidate.matches.length === 1) {
+                    selection = candidate.matches[0];
+                }
+                else {
+                    console.log(`[skiller] Skipping '${candidate.ruleName}' because it has multiple exact matches.`);
+                    continue;
+                }
+            }
+            else {
+                selection = await promptForReplacement(candidate);
+            }
+            if (!selection)
+                continue;
+            if (selection !== 'cleanup') {
+                await (0, skills_cli_1.runSkillsCli)(projectRoot, (0, RulesToSkillsMigration_1.buildRulesReplacementInstallArgs)(selection));
+            }
+            await (0, RulesToSkillsMigration_1.removeLocalRuleReplacementState)(projectRoot, candidate.ruleName, false);
+            replacedCount += 1;
+            console.log(`[skiller] Replaced local rule '${candidate.ruleName}'.`);
+        }
+        if (replacedCount === 0) {
+            console.log('[skiller] No local rules were replaced.');
+            return;
+        }
+        console.log('[skiller] Replacement pass completed. Run skiller apply to refresh derived agent outputs.');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`${constants_1.ERROR_PREFIX} ${message}`);
+        process.exit(1);
+    }
+}
+async function addHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        'add',
+        ...(argv.args ?? []),
+    ]);
+}
+async function removeHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        'remove',
+        ...(argv.args ?? []),
+    ]);
+}
+async function listHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        'list',
+        ...(argv.args ?? []),
+    ]);
+}
+async function findHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        'find',
+        ...(argv.args ?? []),
+    ]);
+}
+async function checkHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        'check',
+        ...(argv.args ?? []),
+    ]);
+}
+async function updateHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        'update',
+        ...(argv.args ?? []),
+    ]);
+}
+async function skillsHandler(argv) {
+    await executeSkillsWrapper(argv['project-root'], [
+        argv.subcommand,
+        ...(argv.args ?? []),
+    ]);
+}
 /**
  * Handler for the 'revert' command.
  */

package/dist/cli/skills-cli.js

@@ -0,0 +1,72 @@
+"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.runSkillsCli = runSkillsCli;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const module_1 = require("module");
+function resolveSkillsCliEntrypoint(projectRoot) {
+    const resolvers = [
+        (0, module_1.createRequire)(path.join(projectRoot, 'package.json')),
+        (0, module_1.createRequire)(path.join(__dirname, '..', '..', 'package.json')),
+    ];
+    for (const resolver of resolvers) {
+        try {
+            const skillsPackageJson = resolver.resolve('skills/package.json');
+            return path.join(path.dirname(skillsPackageJson), 'bin', 'cli.mjs');
+        }
+        catch {
+            // Try the next resolver.
+        }
+    }
+    throw new Error("Cannot find module 'skills/package.json' from the project root or skiller installation");
+}
+async function runSkillsCli(projectRoot, args) {
+    const cliEntrypoint = resolveSkillsCliEntrypoint(projectRoot);
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(process.execPath, [cliEntrypoint, ...args], {
+            cwd: projectRoot,
+            stdio: 'inherit',
+        });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`skills ${args[0] ?? ''} failed with exit code ${code}`.trim()));
+        });
+    });
+}

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_RECURSION_DEPTH = exports.SKILL_MD_FILENAME = exports.CLAUDE_SKILLS_PATH = exports.SKILLS_DIR = exports.DEFAULT_RULES_FILENAME = exports.ERROR_PREFIX = void 0;
+exports.MAX_RECURSION_DEPTH = exports.SKILL_MD_FILENAME = exports.CLAUDE_SKILLS_PATH = exports.CANONICAL_SKILLS_PATH = exports.SKILLS_DIR = exports.DEFAULT_RULES_FILENAME = exports.ERROR_PREFIX = void 0;
 exports.actionPrefix = actionPrefix;
 exports.createSkillerError = createSkillerError;
 exports.logVerbose = logVerbose;
@@ -50,6 +50,7 @@ function logVerboseInfo(message, isVerbose, dryRun = false) {
 }
 // Skills-related constants
 exports.SKILLS_DIR = 'skills';
+exports.CANONICAL_SKILLS_PATH = '.agents/skills';
 exports.CLAUDE_SKILLS_PATH = '.claude/skills';
 exports.SKILL_MD_FILENAME = 'SKILL.md';
 // Security: Maximum recursion depth to prevent DoS via deeply nested directories

package/dist/core/ClaudePluginMigration.js

@@ -0,0 +1,229 @@
+"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.planClaudePluginSkillsMigration = planClaudePluginSkillsMigration;
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const project_paths_1 = require("./project-paths");
+const SkillsManifest_1 = require("./SkillsManifest");
+function getClaudeHomeDir() {
+    return process.env.HOME || os.homedir();
+}
+async function readJsonFile(filePath) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function parsePluginId(pluginId) {
+    const atIndex = pluginId.lastIndexOf('@');
+    if (atIndex <= 0 || atIndex === pluginId.length - 1)
+        return null;
+    return {
+        pluginName: pluginId.slice(0, atIndex),
+        marketplaceId: pluginId.slice(atIndex + 1),
+    };
+}
+function normalizeInstallSource(source) {
+    if (!source || typeof source !== 'object')
+        return null;
+    const raw = source;
+    if (raw.source === 'github' && typeof raw.repo === 'string') {
+        return raw.repo;
+    }
+    if ((raw.source === 'git' || raw.source === 'url') &&
+        typeof raw.url === 'string') {
+        return raw.url;
+    }
+    return null;
+}
+async function readEnabledPluginIds(projectRoot) {
+    const settingsPath = path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR, 'settings.json');
+    const raw = await readJsonFile(settingsPath);
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const enabledPlugins = raw.enabledPlugins;
+    if (!enabledPlugins || typeof enabledPlugins !== 'object')
+        return [];
+    return Object.entries(enabledPlugins)
+        .filter(([, enabled]) => enabled === true)
+        .map(([pluginId]) => pluginId)
+        .sort((a, b) => a.localeCompare(b));
+}
+async function readManifestPluginIds(projectRoot) {
+    const manifestPaths = [
+        path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, SkillsManifest_1.SKILLS_MANIFEST_FILENAME),
+        path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR, SkillsManifest_1.SKILLS_MANIFEST_FILENAME),
+    ];
+    const pluginIds = new Set();
+    for (const manifestPath of manifestPaths) {
+        const raw = await readJsonFile(manifestPath);
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const targets = raw.targets;
+        if (!targets || typeof targets !== 'object')
+            continue;
+        for (const entries of Object.values(targets)) {
+            if (!Array.isArray(entries))
+                continue;
+            for (const entry of entries) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const sourceType = entry.sourceType;
+                const pluginId = entry.pluginId;
+                if (sourceType === 'plugin' && typeof pluginId === 'string') {
+                    pluginIds.add(pluginId);
+                }
+            }
+        }
+    }
+    return [...pluginIds].sort((a, b) => a.localeCompare(b));
+}
+async function readProjectMarketplaceRecords(projectRoot) {
+    const settingsPath = path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR, 'settings.json');
+    const raw = await readJsonFile(settingsPath);
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const marketplaces = raw.extraKnownMarketplaces;
+    if (!marketplaces || typeof marketplaces !== 'object')
+        return {};
+    return Object.fromEntries(Object.entries(marketplaces).filter(([, value]) => value && typeof value === 'object'));
+}
+async function readHomeMarketplaceRecords() {
+    const knownPath = path.join(getClaudeHomeDir(), '.claude', 'plugins', 'known_marketplaces.json');
+    const raw = await readJsonFile(knownPath);
+    if (!raw || typeof raw !== 'object')
+        return {};
+    return raw;
+}
+function mergeMarketplaceRecords(homeRecords, projectRecords) {
+    return {
+        ...homeRecords,
+        ...projectRecords,
+    };
+}
+async function readMarketplacePlugins(marketplaceId, marketplace) {
+    const candidates = [];
+    if (typeof marketplace?.installLocation === 'string') {
+        candidates.push(path.join(marketplace.installLocation, '.claude-plugin', 'marketplace.json'));
+    }
+    candidates.push(path.join(getClaudeHomeDir(), '.claude', 'plugins', 'marketplaces', marketplaceId, '.claude-plugin', 'marketplace.json'));
+    for (const candidate of candidates) {
+        const raw = await readJsonFile(candidate);
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const plugins = raw.plugins;
+        if (!Array.isArray(plugins))
+            continue;
+        const next = {};
+        for (const plugin of plugins) {
+            if (!plugin || typeof plugin !== 'object')
+                continue;
+            const pluginName = plugin.name;
+            if (typeof pluginName !== 'string')
+                continue;
+            next[pluginName] = {
+                source: plugin.source,
+            };
+        }
+        return next;
+    }
+    return {};
+}
+function sortPlan(installsBySource, unresolved) {
+    const installs = [...installsBySource.entries()]
+        .map(([source, info]) => ({
+        source,
+        pluginIds: [...info.pluginIds].sort((a, b) => a.localeCompare(b)),
+        strategy: info.strategy,
+    }))
+        .sort((a, b) => a.source.localeCompare(b.source));
+    return {
+        installs,
+        unresolved: [...unresolved].sort((a, b) => a.pluginId.localeCompare(b.pluginId)),
+    };
+}
+async function planClaudePluginSkillsMigration(projectRoot) {
+    const pluginIds = new Set([
+        ...(await readEnabledPluginIds(projectRoot)),
+        ...(await readManifestPluginIds(projectRoot)),
+    ]);
+    const homeMarketplaces = await readHomeMarketplaceRecords();
+    const projectMarketplaces = await readProjectMarketplaceRecords(projectRoot);
+    const marketplaces = mergeMarketplaceRecords(homeMarketplaces, projectMarketplaces);
+    const installsBySource = new Map();
+    const unresolved = [];
+    const pluginCatalogCache = new Map();
+    for (const pluginId of [...pluginIds].sort((a, b) => a.localeCompare(b))) {
+        const parts = parsePluginId(pluginId);
+        if (!parts) {
+            unresolved.push({
+                pluginId,
+                reason: 'Plugin id is not in <plugin>@<marketplace> format',
+            });
+            continue;
+        }
+        const marketplace = marketplaces[parts.marketplaceId];
+        let pluginDescriptors = pluginCatalogCache.get(parts.marketplaceId);
+        if (!pluginDescriptors) {
+            pluginDescriptors = await readMarketplacePlugins(parts.marketplaceId, marketplace);
+            pluginCatalogCache.set(parts.marketplaceId, pluginDescriptors);
+        }
+        const pluginDescriptor = pluginDescriptors[parts.pluginName];
+        const pluginSource = normalizeInstallSource(pluginDescriptor?.source);
+        const marketplaceSource = normalizeInstallSource(marketplace?.source);
+        const resolvedSource = pluginSource ?? marketplaceSource;
+        if (!resolvedSource) {
+            unresolved.push({
+                pluginId,
+                reason: `No repo or URL source could be inferred for marketplace ${parts.marketplaceId}`,
+            });
+            continue;
+        }
+        const existing = installsBySource.get(resolvedSource);
+        if (existing) {
+            existing.pluginIds.add(pluginId);
+            continue;
+        }
+        installsBySource.set(resolvedSource, {
+            pluginIds: new Set([pluginId]),
+            strategy: pluginSource ? 'plugin-source' : 'marketplace-source',
+        });
+    }
+    return sortPlan(installsBySource, unresolved);
+}