@swarmify/agents-cli 1.4.0 → 1.5.0

package/dist/index.js

@@ -3,6 +3,11 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
 import { checkbox, confirm, select } from '@inquirer/prompts';
+function isPromptCancelled(err) {
+    return err instanceof Error && (err.name === 'ExitPromptError' ||
+        err.message.includes('force closed') ||
+        err.message.includes('User force closed'));
+}
 import { AGENTS, ALL_AGENT_IDS, MCP_CAPABLE_AGENTS, SKILLS_CAPABLE_AGENTS, HOOKS_CAPABLE_AGENTS, getAllCliStates, isCliInstalled, getCliVersion, isMcpRegistered, registerMcp, unregisterMcp, listInstalledMcpsWithScope, promoteMcpToUser, } from './lib/agents.js';
 import { readManifest, writeManifest, createDefaultManifest, MANIFEST_FILENAME, } from './lib/manifest.js';
 import { readState, ensureAgentsDir, getRepoLocalPath, getScope, setScope, removeScope, getScopesByPriority, getScopePriority, } from './lib/state.js';
@@ -195,24 +200,65 @@ program
     }
     console.log();
 });
+// =============================================================================
+// PULL COMMAND
+// =============================================================================
+// Agent name aliases for flexible input
+const AGENT_NAME_ALIASES = {
+    claude: 'claude',
+    'claude-code': 'claude',
+    cc: 'claude',
+    codex: 'codex',
+    'openai-codex': 'codex',
+    cx: 'codex',
+    gemini: 'gemini',
+    'gemini-cli': 'gemini',
+    gx: 'gemini',
+    cursor: 'cursor',
+    'cursor-agent': 'cursor',
+    cr: 'cursor',
+    opencode: 'opencode',
+    oc: 'opencode',
+};
+function resolveAgentName(input) {
+    return AGENT_NAME_ALIASES[input.toLowerCase()] || null;
+}
+function isAgentName(input) {
+    return resolveAgentName(input) !== null;
+}
 program
-    .command('pull [source]')
+    .command('pull [source] [agent]')
     .description('Pull and sync from remote .agents repo')
-    .option('-y, --yes', 'Skip interactive prompts')
-    .option('-f, --force', 'Overwrite existing resources without asking')
+    .option('-y, --yes', 'Auto-confirm and skip all conflicts')
+    .option('-f, --force', 'Auto-confirm and overwrite all conflicts')
     .option('-s, --scope <scope>', 'Target scope (default: user)', 'user')
     .option('--dry-run', 'Show what would change')
     .option('--skip-clis', 'Skip CLI version sync')
     .option('--skip-mcp', 'Skip MCP registration')
-    .action(async (source, options) => {
+    .action(async (arg1, arg2, options) => {
+    // Parse source and agent filter from positional args
+    let targetSource;
+    let agentFilter;
+    if (arg1) {
+        if (isAgentName(arg1)) {
+            // agents pull claude
+            agentFilter = resolveAgentName(arg1);
+        }
+        else {
+            // agents pull gh:user/repo [agent]
+            targetSource = arg1;
+            if (arg2 && isAgentName(arg2)) {
+                agentFilter = resolveAgentName(arg2);
+            }
+        }
+    }
     const scopeName = options.scope;
     const meta = readState();
     const existingScope = meta.scopes[scopeName];
     // Try: 1) provided source, 2) existing scope source, 3) fall back to system scope
-    let targetSource = source || existingScope?.source;
+    targetSource = targetSource || existingScope?.source;
     let effectiveScope = scopeName;
     if (!targetSource && scopeName === 'user') {
-        // Fall back to system scope if user scope has no source
         const systemScope = meta.scopes['system'];
         if (systemScope?.source) {
             targetSource = systemScope.source;
@@ -221,13 +267,19 @@ program
         }
     }
     if (!targetSource) {
-        console.log(chalk.red(`No source specified for scope '${scopeName}'.`));
-        const scopeHint = scopeName === 'user' ? '' : ` --scope ${scopeName}`;
-        console.log(chalk.gray(`  Usage: agents pull <source>${scopeHint}`));
-        console.log(chalk.gray('  Example: agents pull gh:username/.agents'));
-        process.exit(1);
+        if (scopeName === 'user' && Object.keys(meta.scopes).length === 0) {
+            console.log(chalk.gray(`First run detected. Initializing from ${DEFAULT_SYSTEM_REPO}...\n`));
+            targetSource = DEFAULT_SYSTEM_REPO;
+            effectiveScope = 'system';
+        }
+        else {
+            console.log(chalk.red(`No source specified for scope '${scopeName}'.`));
+            const scopeHint = scopeName === 'user' ? '' : ` --scope ${scopeName}`;
+            console.log(chalk.gray(`  Usage: agents pull <source>${scopeHint}`));
+            console.log(chalk.gray('  Example: agents pull gh:username/.agents'));
+            process.exit(1);
+        }
     }
-    // Prevent modification of readonly scopes (but allow syncing from them)
     const targetScopeConfig = meta.scopes[effectiveScope];
     const isReadonly = targetScopeConfig?.readonly || effectiveScope === 'system';
     const isUserScope = effectiveScope === 'user';
@@ -241,64 +293,18 @@ program
             console.log(chalk.yellow(`No ${MANIFEST_FILENAME} found in repository`));
         }
         // Discover all assets
-        const commands = discoverCommands(localPath);
-        const skills = discoverSkillsFromRepo(localPath);
+        const allCommands = discoverCommands(localPath);
+        const allSkills = discoverSkillsFromRepo(localPath);
         const discoveredHooks = discoverHooksFromRepo(localPath);
-        const totalHooks = discoveredHooks.shared.length +
-            Object.values(discoveredHooks.agentSpecific).reduce((sum, arr) => sum + arr.length, 0);
-        console.log(chalk.bold(`\nDiscovered assets:\n`));
-        if (commands.length > 0) {
-            console.log(`  Commands: ${commands.length}`);
-            for (const command of commands.slice(0, 5)) {
-                const src = command.isShared ? 'shared' : command.agentSpecific;
-                console.log(`    ${chalk.cyan(command.name.padEnd(18))} ${chalk.gray(src)}`);
-            }
-            if (commands.length > 5) {
-                console.log(chalk.gray(`    ... and ${commands.length - 5} more`));
-            }
-        }
-        if (skills.length > 0) {
-            console.log(`  Skills: ${skills.length}`);
-            for (const skill of skills.slice(0, 5)) {
-                console.log(`    ${chalk.cyan(skill.name.padEnd(18))} ${chalk.gray(skill.metadata.description || '')}`);
-            }
-            if (skills.length > 5) {
-                console.log(chalk.gray(`    ... and ${skills.length - 5} more`));
-            }
-        }
-        if (totalHooks > 0) {
-            console.log(`  Hooks: ${totalHooks}`);
-            for (const name of discoveredHooks.shared.slice(0, 3)) {
-                console.log(`    ${chalk.cyan(name.padEnd(18))} ${chalk.gray('shared')}`);
-            }
-            for (const [agentId, hooks] of Object.entries(discoveredHooks.agentSpecific)) {
-                for (const name of hooks.slice(0, 2)) {
-                    console.log(`    ${chalk.cyan(name.padEnd(18))} ${chalk.gray(agentId)}`);
-                }
-            }
-            if (totalHooks > 5) {
-                console.log(chalk.gray(`    ... and more`));
-            }
-        }
-        const mcpCount = manifest?.mcp ? Object.keys(manifest.mcp).length : 0;
-        if (mcpCount > 0) {
-            console.log(`  MCP Servers: ${mcpCount}`);
-            for (const name of Object.keys(manifest.mcp).slice(0, 5)) {
-                console.log(`    ${chalk.cyan(name)}`);
-            }
-            if (mcpCount > 5) {
-                console.log(chalk.gray(`    ... and ${mcpCount - 5} more`));
-            }
-        }
-        if (options.dryRun) {
-            console.log(chalk.yellow('\nDry run - no changes made'));
-            return;
-        }
+        // Determine which agents to sync
         let selectedAgents;
-        let method;
-        if (options.yes) {
+        if (agentFilter) {
+            // Single agent filter
+            selectedAgents = [agentFilter];
+            console.log(chalk.gray(`\nFiltering for ${AGENTS[agentFilter].name} only\n`));
+        }
+        else if (options.yes || options.force) {
             selectedAgents = (manifest?.defaults?.agents || ['claude', 'codex', 'gemini']);
-            method = manifest?.defaults?.method || 'symlink';
         }
         else {
             const installedAgents = ALL_AGENT_IDS.filter((id) => isCliInstalled(id) || id === 'cursor');
@@ -310,225 +316,323 @@ program
                     checked: (manifest?.defaults?.agents || ['claude', 'codex', 'gemini']).includes(id),
                 })),
             });
-            method = await select({
-                message: 'Installation method:',
-                choices: [
-                    { name: 'Symlink (updates automatically)', value: 'symlink' },
-                    { name: 'Copy (independent files)', value: 'copy' },
-                ],
-                default: manifest?.defaults?.method || 'symlink',
-            });
         }
-        // Detect conflicts
-        const conflicts = [];
-        // Check command conflicts
-        for (const command of commands) {
-            for (const agentId of selectedAgents) {
-                if (!isCliInstalled(agentId) && agentId !== 'cursor')
-                    continue;
+        // Filter agents to only installed ones (plus cursor which doesn't need CLI)
+        selectedAgents = selectedAgents.filter((id) => isCliInstalled(id) || id === 'cursor');
+        if (selectedAgents.length === 0) {
+            console.log(chalk.yellow('\nNo agents selected or installed. Nothing to sync.'));
+            return;
+        }
+        // Build resource items with conflict detection
+        const newItems = [];
+        const existingItems = [];
+        // Process commands
+        for (const command of allCommands) {
+            const applicableAgents = selectedAgents.filter((agentId) => {
                 const sourcePath = resolveCommandSource(localPath, command.name, agentId);
-                if (sourcePath && commandExists(agentId, command.name)) {
-                    conflicts.push({ type: 'command', name: command.name, agent: agentId });
-                }
+                return sourcePath !== null;
+            });
+            if (applicableAgents.length === 0)
+                continue;
+            const conflictingAgents = applicableAgents.filter((agentId) => commandExists(agentId, command.name));
+            const newAgents = applicableAgents.filter((agentId) => !commandExists(agentId, command.name));
+            if (conflictingAgents.length > 0) {
+                existingItems.push({ type: 'command', name: command.name, agents: conflictingAgents, isNew: false });
             }
-        }
-        // Check skill conflicts
-        for (const skill of skills) {
-            const skillAgents = SKILLS_CAPABLE_AGENTS.filter((id) => selectedAgents.includes(id) && (isCliInstalled(id) || id === 'cursor'));
-            for (const agentId of skillAgents) {
-                if (skillExists(agentId, skill.name)) {
-                    conflicts.push({ type: 'skill', name: skill.name, agent: agentId });
-                }
+            if (newAgents.length > 0) {
+                newItems.push({ type: 'command', name: command.name, agents: newAgents, isNew: true });
             }
         }
-        // Check hook conflicts
-        const hookAgents = selectedAgents.filter((id) => HOOKS_CAPABLE_AGENTS.includes(id) && isCliInstalled(id));
-        for (const hookName of discoveredHooks.shared) {
-            for (const agentId of hookAgents) {
-                if (hookExists(agentId, hookName)) {
-                    conflicts.push({ type: 'hook', name: hookName, agent: agentId });
-                }
+        // Process skills
+        const skillAgents = SKILLS_CAPABLE_AGENTS.filter((id) => selectedAgents.includes(id));
+        for (const skill of allSkills) {
+            const conflictingAgents = skillAgents.filter((agentId) => skillExists(agentId, skill.name));
+            const newAgents = skillAgents.filter((agentId) => !skillExists(agentId, skill.name));
+            if (conflictingAgents.length > 0) {
+                existingItems.push({ type: 'skill', name: skill.name, agents: conflictingAgents, isNew: false });
             }
-        }
-        for (const [agentIdStr, hookNames] of Object.entries(discoveredHooks.agentSpecific)) {
-            const agentId = agentIdStr;
-            if (hookAgents.includes(agentId)) {
-                for (const hookName of hookNames) {
-                    if (hookExists(agentId, hookName)) {
-                        conflicts.push({ type: 'hook', name: hookName, agent: agentId });
-                    }
-                }
+            if (newAgents.length > 0) {
+                newItems.push({ type: 'skill', name: skill.name, agents: newAgents, isNew: true });
             }
         }
-        // Check MCP conflicts
+        // Process hooks
+        const hookAgents = selectedAgents.filter((id) => HOOKS_CAPABLE_AGENTS.includes(id) && isCliInstalled(id));
+        const allHookNames = [
+            ...discoveredHooks.shared,
+            ...Object.entries(discoveredHooks.agentSpecific)
+                .filter(([agentId]) => hookAgents.includes(agentId))
+                .flatMap(([_, hooks]) => hooks),
+        ];
+        const uniqueHookNames = [...new Set(allHookNames)];
+        for (const hookName of uniqueHookNames) {
+            const conflictingAgents = hookAgents.filter((agentId) => hookExists(agentId, hookName));
+            const newAgents = hookAgents.filter((agentId) => !hookExists(agentId, hookName));
+            if (conflictingAgents.length > 0) {
+                existingItems.push({ type: 'hook', name: hookName, agents: conflictingAgents, isNew: false });
+            }
+            if (newAgents.length > 0) {
+                newItems.push({ type: 'hook', name: hookName, agents: newAgents, isNew: true });
+            }
+        }
+        // Process MCPs
         if (!options.skipMcp && manifest?.mcp) {
             for (const [name, config] of Object.entries(manifest.mcp)) {
                 if (config.transport === 'http' || !config.command)
                     continue;
-                for (const agentId of config.agents) {
-                    if (!isCliInstalled(agentId))
-                        continue;
-                    if (isMcpRegistered(agentId, name)) {
-                        conflicts.push({ type: 'mcp', name, agent: agentId });
-                    }
+                const mcpAgents = config.agents.filter((agentId) => selectedAgents.includes(agentId) && isCliInstalled(agentId));
+                if (mcpAgents.length === 0)
+                    continue;
+                const conflictingAgents = mcpAgents.filter((agentId) => isMcpRegistered(agentId, name));
+                const newAgents = mcpAgents.filter((agentId) => !isMcpRegistered(agentId, name));
+                if (conflictingAgents.length > 0) {
+                    existingItems.push({ type: 'mcp', name, agents: conflictingAgents, isNew: false });
+                }
+                if (newAgents.length > 0) {
+                    newItems.push({ type: 'mcp', name, agents: newAgents, isNew: true });
                 }
             }
         }
-        // Handle conflicts
-        let conflictAction = 'overwrite';
-        if (conflicts.length > 0 && !options.force) {
-            // Deduplicate conflicts by name (show each resource once, not per-agent)
-            const uniqueConflicts = new Map();
-            for (const c of conflicts) {
-                const key = `${c.type}:${c.name}`;
-                if (!uniqueConflicts.has(key)) {
-                    uniqueConflicts.set(key, c);
+        // Display overview
+        console.log(chalk.bold('\nOverview\n'));
+        const formatAgentList = (agents) => agents.map((id) => AGENTS[id].name).join(', ');
+        if (newItems.length > 0) {
+            console.log(chalk.green('  NEW (will install):\n'));
+            const byType = { command: [], skill: [], hook: [], mcp: [] };
+            for (const item of newItems)
+                byType[item.type].push(item);
+            if (byType.command.length > 0) {
+                console.log(`    Commands:`);
+                for (const item of byType.command) {
+                    console.log(`      ${chalk.cyan(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
                 }
             }
-            console.log(chalk.yellow(`\nFound ${uniqueConflicts.size} existing resources that would be overwritten:\n`));
-            const byType = {
-                command: [],
-                skill: [],
-                hook: [],
-                mcp: [],
-            };
-            for (const c of uniqueConflicts.values()) {
-                byType[c.type].push(c.name);
+            if (byType.skill.length > 0) {
+                console.log(`    Skills:`);
+                for (const item of byType.skill) {
+                    console.log(`      ${chalk.cyan(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
             }
+            if (byType.hook.length > 0) {
+                console.log(`    Hooks:`);
+                for (const item of byType.hook) {
+                    console.log(`      ${chalk.cyan(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
+            }
+            if (byType.mcp.length > 0) {
+                console.log(`    MCP Servers:`);
+                for (const item of byType.mcp) {
+                    console.log(`      ${chalk.cyan(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
+            }
+            console.log();
+        }
+        if (existingItems.length > 0) {
+            console.log(chalk.yellow('  EXISTING (conflicts):\n'));
+            const byType = { command: [], skill: [], hook: [], mcp: [] };
+            for (const item of existingItems)
+                byType[item.type].push(item);
             if (byType.command.length > 0) {
-                console.log(`  Commands: ${byType.command.join(', ')}`);
+                console.log(`    Commands:`);
+                for (const item of byType.command) {
+                    console.log(`      ${chalk.yellow(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
             }
             if (byType.skill.length > 0) {
-                console.log(`  Skills: ${byType.skill.join(', ')}`);
+                console.log(`    Skills:`);
+                for (const item of byType.skill) {
+                    console.log(`      ${chalk.yellow(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
             }
             if (byType.hook.length > 0) {
-                console.log(`  Hooks: ${byType.hook.join(', ')}`);
+                console.log(`    Hooks:`);
+                for (const item of byType.hook) {
+                    console.log(`      ${chalk.yellow(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
             }
             if (byType.mcp.length > 0) {
-                console.log(`  MCP Servers: ${byType.mcp.join(', ')}`);
+                console.log(`    MCP Servers:`);
+                for (const item of byType.mcp) {
+                    console.log(`      ${chalk.yellow(item.name.padEnd(20))} ${chalk.gray(formatAgentList(item.agents))}`);
+                }
             }
-            if (!options.yes) {
-                conflictAction = await select({
-                    message: 'How do you want to handle existing resources?',
+            console.log();
+        }
+        if (newItems.length === 0 && existingItems.length === 0) {
+            console.log(chalk.gray('  Nothing to sync.\n'));
+            return;
+        }
+        if (options.dryRun) {
+            console.log(chalk.yellow('Dry run - no changes made'));
+            return;
+        }
+        // Confirmation prompt
+        if (!options.yes && !options.force) {
+            const proceed = await confirm({
+                message: 'Proceed with installation?',
+                default: true,
+            });
+            if (!proceed) {
+                console.log(chalk.yellow('\nSync cancelled'));
+                return;
+            }
+        }
+        // Determine installation method
+        let method;
+        if (options.yes || options.force) {
+            method = manifest?.defaults?.method || 'symlink';
+        }
+        else {
+            method = await select({
+                message: 'Installation method:',
+                choices: [
+                    { name: 'Symlink (updates automatically)', value: 'symlink' },
+                    { name: 'Copy (independent files)', value: 'copy' },
+                ],
+                default: manifest?.defaults?.method || 'symlink',
+            });
+        }
+        // Per-resource conflict decisions
+        const decisions = new Map();
+        if (existingItems.length > 0 && !options.force && !options.yes) {
+            console.log(chalk.bold('\nResolve conflicts:\n'));
+            for (const item of existingItems) {
+                const typeLabel = item.type.charAt(0).toUpperCase() + item.type.slice(1);
+                const agentList = formatAgentList(item.agents);
+                const decision = await select({
+                    message: `${typeLabel} '${item.name}' exists (${agentList})`,
                     choices: [
-                        { name: 'Overwrite all', value: 'overwrite' },
-                        { name: 'Skip existing (only install new)', value: 'skip' },
-                        { name: 'Cancel', value: 'cancel' },
+                        { name: 'Overwrite', value: 'overwrite' },
+                        { name: 'Skip', value: 'skip' },
+                        { name: 'Cancel all', value: 'cancel' },
                     ],
                 });
-                if (conflictAction === 'cancel') {
+                if (decision === 'cancel') {
                     console.log(chalk.yellow('\nSync cancelled'));
                     return;
                 }
+                decisions.set(`${item.type}:${item.name}`, decision);
+            }
+        }
+        else if (options.force) {
+            // Force mode: overwrite all
+            for (const item of existingItems) {
+                decisions.set(`${item.type}:${item.name}`, 'overwrite');
             }
         }
-        const skipExisting = conflictAction === 'skip';
-        const conflictNames = new Set(conflicts.map((c) => `${c.type}:${c.name}:${c.agent}`));
+        else if (options.yes) {
+            // Yes mode: skip all conflicts
+            for (const item of existingItems) {
+                decisions.set(`${item.type}:${item.name}`, 'skip');
+            }
+        }
+        // Install new items (no conflicts)
+        console.log();
+        let installed = { commands: 0, skills: 0, hooks: 0, mcps: 0 };
+        let skipped = { commands: 0, skills: 0, hooks: 0, mcps: 0 };
         // Install commands
-        const installSpinner = ora('Installing commands...').start();
-        let installed = 0;
-        let skipped = 0;
-        for (const command of commands) {
-            for (const agentId of selectedAgents) {
-                if (!isCliInstalled(agentId) && agentId !== 'cursor')
-                    continue;
-                const sourcePath = resolveCommandSource(localPath, command.name, agentId);
-                if (!sourcePath)
-                    continue;
-                const conflictKey = `command:${command.name}:${agentId}`;
-                if (skipExisting && conflictNames.has(conflictKey)) {
-                    skipped++;
-                    continue;
+        const cmdSpinner = ora('Installing commands...').start();
+        for (const item of [...newItems, ...existingItems].filter((i) => i.type === 'command')) {
+            const decision = item.isNew ? 'overwrite' : decisions.get(`command:${item.name}`);
+            if (decision === 'skip') {
+                skipped.commands++;
+                continue;
+            }
+            for (const agentId of item.agents) {
+                const sourcePath = resolveCommandSource(localPath, item.name, agentId);
+                if (sourcePath) {
+                    installCommand(sourcePath, agentId, item.name, method);
+                    installed.commands++;
                 }
-                installCommand(sourcePath, agentId, command.name, method);
-                installed++;
             }
         }
-        if (skipped > 0) {
-            installSpinner.succeed(`Installed ${installed} commands (skipped ${skipped} existing)`);
+        if (skipped.commands > 0) {
+            cmdSpinner.succeed(`Installed ${installed.commands} commands (skipped ${skipped.commands})`);
+        }
+        else if (installed.commands > 0) {
+            cmdSpinner.succeed(`Installed ${installed.commands} commands`);
         }
         else {
-            installSpinner.succeed(`Installed ${installed} command instances`);
+            cmdSpinner.info('No commands to install');
         }
         // Install skills
-        if (skills.length > 0) {
+        const skillItems = [...newItems, ...existingItems].filter((i) => i.type === 'skill');
+        if (skillItems.length > 0) {
             const skillSpinner = ora('Installing skills...').start();
-            let skillsInstalled = 0;
-            let skillsSkipped = 0;
-            for (const skill of skills) {
-                const skillAgents = SKILLS_CAPABLE_AGENTS.filter((id) => selectedAgents.includes(id) && (isCliInstalled(id) || id === 'cursor'));
-                // Check if should skip
-                const shouldSkip = skipExisting && skillAgents.some((agentId) => conflictNames.has(`skill:${skill.name}:${agentId}`));
-                if (shouldSkip) {
-                    skillsSkipped++;
+            for (const item of skillItems) {
+                const decision = item.isNew ? 'overwrite' : decisions.get(`skill:${item.name}`);
+                if (decision === 'skip') {
+                    skipped.skills++;
                     continue;
                 }
-                if (skillAgents.length > 0) {
-                    const result = installSkill(skill.path, skill.name, skillAgents);
+                const skill = allSkills.find((s) => s.name === item.name);
+                if (skill) {
+                    const result = installSkill(skill.path, skill.name, item.agents);
                     if (result.success)
-                        skillsInstalled++;
+                        installed.skills++;
                 }
             }
-            if (skillsSkipped > 0) {
-                skillSpinner.succeed(`Installed ${skillsInstalled} skills (skipped ${skillsSkipped} existing)`);
+            if (skipped.skills > 0) {
+                skillSpinner.succeed(`Installed ${installed.skills} skills (skipped ${skipped.skills})`);
+            }
+            else if (installed.skills > 0) {
+                skillSpinner.succeed(`Installed ${installed.skills} skills`);
             }
             else {
-                skillSpinner.succeed(`Installed ${skillsInstalled} skills`);
+                skillSpinner.info('No skills to install');
             }
         }
         // Install hooks
-        if (totalHooks > 0 && hookAgents.length > 0) {
+        const hookItems = [...newItems, ...existingItems].filter((i) => i.type === 'hook');
+        if (hookItems.length > 0 && hookAgents.length > 0) {
             const hookSpinner = ora('Installing hooks...').start();
-            // Note: installHooks handles its own conflict detection internally
-            // For now, pass the full list - in the future we could filter
             const result = await installHooks(localPath, hookAgents, { scope: 'user' });
             hookSpinner.succeed(`Installed ${result.installed.length} hooks`);
         }
         // Register MCP servers
-        if (!options.skipMcp && manifest?.mcp) {
+        const mcpItems = [...newItems, ...existingItems].filter((i) => i.type === 'mcp');
+        if (mcpItems.length > 0 && manifest?.mcp) {
             const mcpSpinner = ora('Registering MCP servers...').start();
-            let registered = 0;
-            let mcpSkipped = 0;
-            for (const [name, config] of Object.entries(manifest.mcp)) {
-                // Skip HTTP transport MCPs for now (need different registration)
-                if (config.transport === 'http' || !config.command)
+            for (const item of mcpItems) {
+                const decision = item.isNew ? 'overwrite' : decisions.get(`mcp:${item.name}`);
+                if (decision === 'skip') {
+                    skipped.mcps++;
                     continue;
-                for (const agentId of config.agents) {
-                    if (!isCliInstalled(agentId))
-                        continue;
-                    const conflictKey = `mcp:${name}:${agentId}`;
-                    if (conflictNames.has(conflictKey)) {
-                        if (skipExisting) {
-                            mcpSkipped++;
-                            continue;
-                        }
-                        // If overwriting, unregister first then re-register
-                        unregisterMcp(agentId, name);
+                }
+                const config = manifest.mcp[item.name];
+                if (!config || !config.command)
+                    continue;
+                for (const agentId of item.agents) {
+                    if (!item.isNew) {
+                        unregisterMcp(agentId, item.name);
                     }
-                    const result = registerMcp(agentId, name, config.command, config.scope);
+                    const result = registerMcp(agentId, item.name, config.command, config.scope);
                     if (result.success)
-                        registered++;
+                        installed.mcps++;
                 }
             }
-            if (mcpSkipped > 0) {
-                mcpSpinner.succeed(`Registered ${registered} MCP servers (skipped ${mcpSkipped} existing)`);
+            if (skipped.mcps > 0) {
+                mcpSpinner.succeed(`Registered ${installed.mcps} MCP servers (skipped ${skipped.mcps})`);
+            }
+            else if (installed.mcps > 0) {
+                mcpSpinner.succeed(`Registered ${installed.mcps} MCP servers`);
             }
             else {
-                mcpSpinner.succeed(`Registered ${registered} MCP servers`);
+                mcpSpinner.info('No MCP servers to register');
             }
         }
-        // Sync CLI versions (user scope only, unless --skip-clis)
+        // Sync CLI versions (user scope only)
         if (isUserScope && !options.skipClis && manifest?.clis) {
             const cliSpinner = ora('Checking CLI versions...').start();
             const cliUpdates = [];
             for (const [agentIdStr, cliConfig] of Object.entries(manifest.clis)) {
                 const agentId = agentIdStr;
+                if (agentFilter && agentId !== agentFilter)
+                    continue;
                 const agent = AGENTS[agentId];
                 if (!agent || !cliConfig.package)
                     continue;
                 const currentVersion = getCliVersion(agentId);
                 const targetVersion = cliConfig.version;
-                // Skip if same version or if target is "latest" and CLI is installed
                 if (currentVersion === targetVersion)
                     continue;
                 if (targetVersion === 'latest' && currentVersion)
@@ -546,7 +650,7 @@ program
                 cliSpinner.succeed('CLI versions match');
             }
         }
-        // Update scope config (only if not readonly)
+        // Update scope config
         if (!isReadonly) {
             const priority = getScopePriority(effectiveScope);
             setScope(effectiveScope, {
@@ -561,6 +665,10 @@ program
         console.log(chalk.green(`\nSync complete from ${effectiveScope} scope`));
     }
     catch (err) {
+        if (isPromptCancelled(err)) {
+            console.log(chalk.yellow('\nCancelled'));
+            process.exit(0);
+        }
         spinner.fail('Failed to sync');
         console.error(chalk.red(err.message));
         process.exit(1);
@@ -1968,7 +2076,7 @@ program
     const spinner = ora('Checking for updates...').start();
     try {
         // Get current version from package.json
-        const currentVersion = program.version();
+        const currentVersion = program.version() || '0.0.0';
         // Fetch latest version from npm
         const response = await fetch('https://registry.npmjs.org/@swarmify/agents-cli/latest');
         if (!response.ok) {
@@ -1980,7 +2088,7 @@ program
             spinner.succeed(`Already on latest version (${currentVersion})`);
             return;
         }
-        spinner.text = `Upgrading from ${currentVersion} to ${latestVersion}...`;
+        spinner.text = `Upgrading to ${latestVersion}...`;
         // Detect package manager
         const { execSync } = await import('child_process');
         let cmd;
@@ -2009,8 +2117,11 @@ program
                 cmd = 'npm install -g @swarmify/agents-cli@latest';
             }
         }
-        execSync(cmd, { stdio: 'inherit' });
+        // Run silently (suppress npm/bun output)
+        execSync(cmd, { stdio: 'pipe' });
         spinner.succeed(`Upgraded to ${latestVersion}`);
+        // Show what's new from changelog
+        await showWhatsNew(currentVersion, latestVersion);
     }
     catch (err) {
         spinner.fail('Upgrade failed');
@@ -2019,5 +2130,67 @@ program
         process.exit(1);
     }
 });
+async function showWhatsNew(fromVersion, toVersion) {
+    try {
+        // Fetch changelog from npm package
+        const response = await fetch(`https://unpkg.com/@swarmify/agents-cli@${toVersion}/CHANGELOG.md`);
+        if (!response.ok)
+            return;
+        const changelog = await response.text();
+        const lines = changelog.split('\n');
+        // Parse changelog to find relevant sections
+        const relevantChanges = [];
+        let inRelevantSection = false;
+        let currentVersion = '';
+        for (const line of lines) {
+            // Check for version header (## 1.5.0)
+            const versionMatch = line.match(/^## (\d+\.\d+\.\d+)/);
+            if (versionMatch) {
+                currentVersion = versionMatch[1];
+                // Include versions newer than fromVersion
+                const isNewer = currentVersion !== fromVersion &&
+                    compareVersions(currentVersion, fromVersion) > 0;
+                inRelevantSection = isNewer;
+                if (inRelevantSection) {
+                    relevantChanges.push('');
+                    relevantChanges.push(chalk.bold(`v${currentVersion}`));
+                }
+                continue;
+            }
+            if (inRelevantSection && line.trim()) {
+                // Format the line
+                if (line.startsWith('**') && line.endsWith('**')) {
+                    // Section header like **Pull command redesign**
+                    relevantChanges.push(chalk.cyan(line.replace(/\*\*/g, '')));
+                }
+                else if (line.startsWith('- ')) {
+                    // Bullet point
+                    relevantChanges.push(chalk.gray(`  ${line}`));
+                }
+            }
+        }
+        if (relevantChanges.length > 0) {
+            console.log(chalk.bold("\nWhat's new:\n"));
+            for (const line of relevantChanges) {
+                console.log(line);
+            }
+            console.log();
+        }
+    }
+    catch {
+        // Silently ignore changelog fetch errors
+    }
+}
+function compareVersions(a, b) {
+    const partsA = a.split('.').map(Number);
+    const partsB = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (partsA[i] > partsB[i])
+            return 1;
+        if (partsA[i] < partsB[i])
+            return -1;
+    }
+    return 0;
+}
 program.parse();
 //# sourceMappingURL=index.js.map