mcpick 0.0.9 → 0.0.11

package/dist/commands/edit-plugins.js

@@ -1,56 +1,201 @@
-import { log, multiselect, note } from '@clack/prompts';
+import { confirm, isCancel, log, multiselect, note, select, text, } from '@clack/prompts';
 import { build_enabled_plugins, get_all_plugins, read_claude_settings, write_claude_settings, } from '../core/settings.js';
+import { install_plugin_via_cli, uninstall_plugin_via_cli, update_plugin_via_cli, } from '../utils/claude-cli.js';
+async function handle_toggle() {
+    const settings = await read_claude_settings();
+    const plugins = get_all_plugins(settings);
+    if (plugins.length === 0) {
+        note('No plugins found in ~/.claude/settings.json.\n' +
+            'Install plugins via Claude Code: /plugin');
+        return;
+    }
+    const plugin_choices = plugins.map((plugin) => ({
+        value: `${plugin.name}@${plugin.marketplace}`,
+        label: plugin.name,
+        hint: plugin.marketplace,
+    }));
+    const currently_enabled = plugins
+        .filter((p) => p.enabled)
+        .map((p) => `${p.name}@${p.marketplace}`);
+    const selected = await multiselect({
+        message: 'Select plugins to enable:',
+        options: plugin_choices,
+        initialValues: currently_enabled,
+        required: false,
+    });
+    if (typeof selected === 'symbol')
+        return;
+    const selected_set = new Set(selected);
+    const updated_plugins = plugins.map((plugin) => ({
+        ...plugin,
+        enabled: selected_set.has(`${plugin.name}@${plugin.marketplace}`),
+    }));
+    const enabled_plugins = build_enabled_plugins(updated_plugins);
+    await write_claude_settings({ enabledPlugins: enabled_plugins });
+    const enabled_count = updated_plugins.filter((p) => p.enabled).length;
+    const disabled_count = updated_plugins.filter((p) => !p.enabled).length;
+    note(`Plugins updated!\n` +
+        `Enabled: ${enabled_count}, Disabled: ${disabled_count}`);
+    const newly_enabled = updated_plugins.filter((p) => p.enabled &&
+        !currently_enabled.includes(`${p.name}@${p.marketplace}`));
+    const newly_disabled = updated_plugins.filter((p) => !p.enabled &&
+        currently_enabled.includes(`${p.name}@${p.marketplace}`));
+    if (newly_enabled.length > 0) {
+        log.success(`Enabled: ${newly_enabled.map((p) => p.name).join(', ')}`);
+    }
+    if (newly_disabled.length > 0) {
+        log.warn(`Disabled: ${newly_disabled.map((p) => p.name).join(', ')}`);
+    }
+}
+async function handle_install() {
+    const key = await text({
+        message: 'Plugin to install (name@marketplace):',
+        placeholder: 'e.g. commit-commands@claude-plugins-official',
+        validate: (value) => {
+            if (!value || value.trim().length === 0) {
+                return 'Plugin key is required';
+            }
+            if (!value.includes('@')) {
+                return 'Format: plugin-name@marketplace-name';
+            }
+        },
+    });
+    if (isCancel(key))
+        return;
+    const scope = await select({
+        message: 'Installation scope:',
+        options: [
+            { value: 'user', label: 'User', hint: 'Global (default)' },
+            {
+                value: 'project',
+                label: 'Project',
+                hint: 'Shared with team',
+            },
+            {
+                value: 'local',
+                label: 'Local',
+                hint: 'This project only (gitignored)',
+            },
+        ],
+    });
+    if (isCancel(scope))
+        return;
+    const result = await install_plugin_via_cli(key, scope);
+    if (result.success) {
+        log.success(`Installed '${key}' (scope: ${scope})`);
+    }
+    else {
+        log.error(result.error ?? 'Unknown error');
+    }
+}
+async function handle_uninstall() {
+    const settings = await read_claude_settings();
+    const plugins = get_all_plugins(settings);
+    if (plugins.length === 0) {
+        log.info('No plugins installed.');
+        return;
+    }
+    const selected = await select({
+        message: 'Select plugin to uninstall:',
+        options: plugins.map((p) => ({
+            value: `${p.name}@${p.marketplace}`,
+            label: p.name,
+            hint: p.marketplace,
+        })),
+    });
+    if (isCancel(selected))
+        return;
+    const should_uninstall = await confirm({
+        message: `Uninstall '${selected}'?`,
+    });
+    if (isCancel(should_uninstall) || !should_uninstall)
+        return;
+    const result = await uninstall_plugin_via_cli(selected);
+    if (result.success) {
+        log.success(`Uninstalled '${selected}'`);
+    }
+    else {
+        log.error(result.error ?? 'Unknown error');
+    }
+}
+async function handle_update() {
+    const settings = await read_claude_settings();
+    const plugins = get_all_plugins(settings);
+    if (plugins.length === 0) {
+        log.info('No plugins installed.');
+        return;
+    }
+    const selected = await select({
+        message: 'Select plugin to update:',
+        options: plugins.map((p) => ({
+            value: `${p.name}@${p.marketplace}`,
+            label: p.name,
+            hint: p.marketplace,
+        })),
+    });
+    if (isCancel(selected))
+        return;
+    const result = await update_plugin_via_cli(selected);
+    if (result.success) {
+        log.success(`Updated '${selected}'`);
+    }
+    else {
+        log.error(result.error ?? 'Unknown error');
+    }
+}
 export async function edit_plugins() {
-    try {
-        const settings = await read_claude_settings();
-        const plugins = get_all_plugins(settings);
-        if (plugins.length === 0) {
-            note('No plugins found in ~/.claude/settings.json.\n' +
-                'Install plugins via Claude Code: /plugin');
-            return;
-        }
-        const plugin_choices = plugins.map((plugin) => ({
-            value: `${plugin.name}@${plugin.marketplace}`,
-            label: plugin.name,
-            hint: plugin.marketplace,
-        }));
-        const currently_enabled = plugins
-            .filter((p) => p.enabled)
-            .map((p) => `${p.name}@${p.marketplace}`);
-        const selected = await multiselect({
-            message: 'Select plugins to enable:',
-            options: plugin_choices,
-            initialValues: currently_enabled,
-            required: false,
+    while (true) {
+        const action = await select({
+            message: 'Plugin management:',
+            options: [
+                {
+                    value: 'toggle',
+                    label: 'Enable / Disable plugins',
+                    hint: 'Toggle plugins on/off',
+                },
+                {
+                    value: 'install',
+                    label: 'Install plugin',
+                    hint: 'Install from a marketplace',
+                },
+                {
+                    value: 'uninstall',
+                    label: 'Uninstall plugin',
+                    hint: 'Remove a plugin entirely',
+                },
+                {
+                    value: 'update',
+                    label: 'Update plugin',
+                    hint: 'Update to latest version',
+                },
+                {
+                    value: 'back',
+                    label: 'Back',
+                    hint: 'Return to main menu',
+                },
+            ],
         });
-        if (typeof selected === 'symbol') {
+        if (isCancel(action) || action === 'back')
             return;
+        try {
+            switch (action) {
+                case 'toggle':
+                    await handle_toggle();
+                    break;
+                case 'install':
+                    await handle_install();
+                    break;
+                case 'uninstall':
+                    await handle_uninstall();
+                    break;
+                case 'update':
+                    await handle_update();
+                    break;
+            }
         }
-        const selected_set = new Set(selected);
-        const updated_plugins = plugins.map((plugin) => ({
-            ...plugin,
-            enabled: selected_set.has(`${plugin.name}@${plugin.marketplace}`),
-        }));
-        const enabled_plugins = build_enabled_plugins(updated_plugins);
-        await write_claude_settings({ enabledPlugins: enabled_plugins });
-        const enabled_count = updated_plugins.filter((p) => p.enabled).length;
-        const disabled_count = updated_plugins.filter((p) => !p.enabled).length;
-        note(`Plugins updated!\n` +
-            `Enabled: ${enabled_count}, Disabled: ${disabled_count}`);
-        // Show what changed
-        const newly_enabled = updated_plugins.filter((p) => p.enabled &&
-            !currently_enabled.includes(`${p.name}@${p.marketplace}`));
-        const newly_disabled = updated_plugins.filter((p) => !p.enabled &&
-            currently_enabled.includes(`${p.name}@${p.marketplace}`));
-        if (newly_enabled.length > 0) {
-            log.success(`Enabled: ${newly_enabled.map((p) => p.name).join(', ')}`);
+        catch (err) {
+            log.error(err instanceof Error ? err.message : 'Unknown error');
         }
-        if (newly_disabled.length > 0) {
-            log.warn(`Disabled: ${newly_disabled.map((p) => p.name).join(', ')}`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to edit plugins: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
 //# sourceMappingURL=edit-plugins.js.map

package/dist/commands/manage-cache.js

@@ -0,0 +1,155 @@
+import { confirm, isCancel, log, multiselect, note, select, } from '@clack/prompts';
+import { clean_orphaned_versions, clear_plugin_caches, get_cached_plugins_info, refresh_all_marketplaces, } from '../core/plugin-cache.js';
+function format_status_line(p) {
+    const markers = [];
+    if (p.isVersionStale) {
+        markers.push(`version: ${p.installedVersion} → ${p.latestVersion}`);
+    }
+    if (p.isShaStale) {
+        markers.push('commits behind');
+    }
+    if (p.orphanedVersions.length > 0) {
+        markers.push(`${p.orphanedVersions.length} orphaned`);
+    }
+    const status = markers.length > 0
+        ? `[stale: ${markers.join(', ')}]`
+        : '[up to date]';
+    return `${p.name}@${p.marketplace}  v${p.installedVersion}  ${status}`;
+}
+async function handle_status() {
+    const plugins = await get_cached_plugins_info();
+    if (plugins.length === 0) {
+        log.info('No cached plugins found.');
+        return;
+    }
+    const lines = plugins.map(format_status_line).join('\n');
+    note(lines, 'Plugin Cache Status');
+}
+async function handle_clear() {
+    const plugins = await get_cached_plugins_info();
+    if (plugins.length === 0) {
+        log.info('No cached plugins to clear.');
+        return;
+    }
+    const selected = await multiselect({
+        message: 'Select plugins to clear cache for:',
+        options: plugins.map((p) => {
+            const stale = p.isVersionStale || p.isShaStale;
+            return {
+                value: p.key,
+                label: `${p.name}@${p.marketplace}`,
+                hint: stale
+                    ? `v${p.installedVersion} → ${p.latestVersion ?? 'unknown'} (stale)`
+                    : `v${p.installedVersion}`,
+            };
+        }),
+        initialValues: plugins
+            .filter((p) => p.isVersionStale || p.isShaStale)
+            .map((p) => p.key),
+    });
+    if (isCancel(selected) || selected.length === 0)
+        return;
+    const should_clear = await confirm({
+        message: `Clear cache for ${selected.length} plugin(s)? This will also refresh the marketplace.`,
+    });
+    if (isCancel(should_clear) || !should_clear)
+        return;
+    const result = await clear_plugin_caches(selected);
+    for (const key of result.cleared) {
+        log.success(`Cleared: ${key}`);
+    }
+    for (const err of result.errors) {
+        log.error(`Error: ${err}`);
+    }
+    if (result.cleared.length > 0) {
+        note('Run /reload-plugins in Claude Code or restart your session to apply changes.', 'Next Steps');
+    }
+}
+async function handle_clean_orphaned() {
+    const should_clean = await confirm({
+        message: 'Remove all orphaned plugin version directories?',
+    });
+    if (isCancel(should_clean) || !should_clean)
+        return;
+    const result = await clean_orphaned_versions();
+    if (result.cleaned === 0) {
+        log.info('No orphaned versions found.');
+    }
+    else {
+        for (const p of result.paths) {
+            log.success(`Removed: ${p}`);
+        }
+        log.info(`Cleaned ${result.cleaned} orphaned version(s).`);
+    }
+}
+async function handle_refresh() {
+    const should_refresh = await confirm({
+        message: 'Refresh all marketplace clones (git pull)?',
+    });
+    if (isCancel(should_refresh) || !should_refresh)
+        return;
+    const results = await refresh_all_marketplaces();
+    if (results.size === 0) {
+        log.info('No marketplaces configured.');
+        return;
+    }
+    for (const [name, result] of results) {
+        if (result.success) {
+            log.success(`${name}: refreshed`);
+        }
+        else {
+            log.error(`${name}: ${result.error}`);
+        }
+    }
+}
+export async function manage_cache() {
+    while (true) {
+        const action = await select({
+            message: 'Plugin cache management:',
+            options: [
+                {
+                    value: 'status',
+                    label: 'View cache status',
+                    hint: 'Show plugins with staleness info',
+                },
+                {
+                    value: 'clear',
+                    label: 'Clear plugin caches',
+                    hint: 'Refresh marketplace + clear selected caches',
+                },
+                {
+                    value: 'clean-orphaned',
+                    label: 'Clean orphaned versions',
+                    hint: 'Remove old version directories',
+                },
+                {
+                    value: 'refresh',
+                    label: 'Refresh marketplaces',
+                    hint: 'Git pull all marketplace clones',
+                },
+                {
+                    value: 'back',
+                    label: 'Back',
+                    hint: 'Return to main menu',
+                },
+            ],
+        });
+        if (isCancel(action) || action === 'back')
+            return;
+        switch (action) {
+            case 'status':
+                await handle_status();
+                break;
+            case 'clear':
+                await handle_clear();
+                break;
+            case 'clean-orphaned':
+                await handle_clean_orphaned();
+                break;
+            case 'refresh':
+                await handle_refresh();
+                break;
+        }
+    }
+}
+//# sourceMappingURL=manage-cache.js.map

package/dist/commands/restore.js

@@ -1,50 +1,101 @@
-import { confirm, note, select } from '@clack/prompts';
+import { confirm, isCancel, log, note, select } from '@clack/prompts';
 import { readFile } from 'node:fs/promises';
 import { read_claude_config, write_claude_config, } from '../core/config.js';
-import { list_backups } from '../core/registry.js';
+import { list_backups, list_plugin_backups, } from '../core/registry.js';
+import { write_claude_settings } from '../core/settings.js';
 export async function restore_config() {
     try {
-        const backups = await list_backups();
-        if (backups.length === 0) {
-            note('No backups found.');
-            return;
-        }
-        const backup_choices = backups.map((backup) => ({
-            value: backup.path,
-            label: `${backup.filename} (${backup.timestamp.toLocaleString()})`,
-            hint: format_time_ago(backup.timestamp),
-        }));
-        const selected_backup_path = await select({
-            message: 'Select backup to restore:',
-            options: backup_choices,
+        const restore_type = await select({
+            message: 'What would you like to restore?',
+            options: [
+                {
+                    value: 'mcp',
+                    label: 'MCP servers',
+                    hint: 'Restore server configuration',
+                },
+                {
+                    value: 'plugins',
+                    label: 'Plugins',
+                    hint: 'Restore plugin enabled/disabled state',
+                },
+            ],
         });
-        if (typeof selected_backup_path === 'symbol') {
+        if (isCancel(restore_type))
             return;
+        if (restore_type === 'mcp') {
+            await restore_mcp();
         }
-        const should_restore = await confirm({
-            message: 'This will replace your current MCP servers configuration. Continue?',
-        });
-        if (typeof should_restore === 'symbol' || !should_restore) {
-            return;
+        else {
+            await restore_plugins();
         }
-        // Read the backup file
-        const backup_content = await readFile(selected_backup_path, 'utf-8');
-        const backup_data = JSON.parse(backup_content);
-        // Read current config and merge
-        const current_config = await read_claude_config();
-        const updated_config = {
-            ...current_config,
-            mcpServers: backup_data.mcpServers || {},
-        };
-        // Write back only the updated config
-        await write_claude_config(updated_config);
-        const server_count = Object.keys(backup_data.mcpServers || {}).length;
-        note(`MCP servers configuration restored successfully!\n(${server_count} servers restored)`);
     }
     catch (error) {
         throw new Error(`Failed to restore configuration: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+async function restore_mcp() {
+    const backups = await list_backups();
+    if (backups.length === 0) {
+        note('No MCP server backups found.');
+        return;
+    }
+    const backup_choices = backups.map((backup) => ({
+        value: backup.path,
+        label: `${backup.filename} (${backup.timestamp.toLocaleString()})`,
+        hint: format_time_ago(backup.timestamp),
+    }));
+    const selected_backup_path = await select({
+        message: 'Select backup to restore:',
+        options: backup_choices,
+    });
+    if (isCancel(selected_backup_path))
+        return;
+    const should_restore = await confirm({
+        message: 'This will replace your current MCP servers configuration. Continue?',
+    });
+    if (isCancel(should_restore) || !should_restore)
+        return;
+    const backup_content = await readFile(selected_backup_path, 'utf-8');
+    const backup_data = JSON.parse(backup_content);
+    const current_config = await read_claude_config();
+    const updated_config = {
+        ...current_config,
+        mcpServers: backup_data.mcpServers || {},
+    };
+    await write_claude_config(updated_config);
+    const server_count = Object.keys(backup_data.mcpServers || {}).length;
+    log.success(`MCP servers restored (${server_count} servers)`);
+}
+async function restore_plugins() {
+    const backups = await list_plugin_backups();
+    if (backups.length === 0) {
+        note('No plugin backups found.');
+        return;
+    }
+    const backup_choices = backups.map((backup) => ({
+        value: backup.path,
+        label: `${backup.filename} (${backup.timestamp.toLocaleString()})`,
+        hint: format_time_ago(backup.timestamp),
+    }));
+    const selected_backup_path = await select({
+        message: 'Select plugin backup to restore:',
+        options: backup_choices,
+    });
+    if (isCancel(selected_backup_path))
+        return;
+    const should_restore = await confirm({
+        message: 'This will replace your current plugin configuration. Continue?',
+    });
+    if (isCancel(should_restore) || !should_restore)
+        return;
+    const backup_content = await readFile(selected_backup_path, 'utf-8');
+    const backup_data = JSON.parse(backup_content);
+    await write_claude_settings({
+        enabledPlugins: backup_data.enabledPlugins || {},
+    });
+    const plugin_count = Object.keys(backup_data.enabledPlugins || {}).length;
+    log.success(`Plugins restored (${plugin_count} plugins)`);
+}
 function format_time_ago(date) {
     const now = new Date();
     const diff = now.getTime() - date.getTime();