link-agents 0.9.0

package/dist/cli/interactive.js

@@ -0,0 +1,1176 @@
+import { intro, outro, select, multiselect, confirm, spinner, note, } from "@clack/prompts";
+import checkboxPlus from "inquirer-checkbox-plus-plus";
+import chalk from "chalk";
+import { discoverAssets } from "../utils/discovery.js";
+import { fileExists, commandExists, readFileSafe, hashContent, } from "../utils/fs.js";
+import { mergeMcpAssets, parseMcpConfig, detectMcpFormat, serializeMcpConfig, formatEnvForDisplay, compareServerConfigs, validateMcpConfig, getMcpCommands, findRemovedServers, } from "../utils/mcp.js";
+import { calculateSimilarity, getSimilarityLabel, formatRelativeTime, } from "../utils/similarity.js";
+import { remapRelativePathForTarget, buildTargetAbsolutePath, } from "../utils/paths.js";
+import { shouldSkipTargetAsset } from "../utils/syncFilters.js";
+/** Format asset count with type breakdown for display */
+function formatAssetSummary(assets) {
+    if (assets.length === 0)
+        return "empty";
+    const byType = {};
+    for (const a of assets) {
+        byType[a.type] = (byType[a.type] || 0) + 1;
+    }
+    const typeLabels = {
+        agents: "agent",
+        commands: "cmd",
+        rules: "rule",
+        skills: "skill",
+        mcp: "mcp",
+        prompts: "prompt",
+    };
+    const parts = [];
+    for (const [type, count] of Object.entries(byType)) {
+        const label = typeLabels[type] || type;
+        parts.push(`${count} ${label}${count > 1 ? "s" : ""}`);
+    }
+    // If too many parts, show total with top 2 types
+    if (parts.length > 3) {
+        const total = assets.length;
+        const topTypes = Object.entries(byType)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 2)
+            .map(([type, count]) => {
+            const label = typeLabels[type] || type;
+            return `${count} ${label}${count > 1 ? "s" : ""}`;
+        });
+        return `${total} files: ${topTypes.join(", ")}...`;
+    }
+    return parts.join(", ");
+}
+export async function runInteractiveFlow(defs, options) {
+    intro(chalk.bold("agsync"));
+    const scope = options.scope === "all" ? await selectScope() : options.scope ?? "all";
+    if (typeof scope === "symbol") {
+        outro("Cancelled.");
+        return { proceed: false, entries: [], scope: "all", direction: "sync" };
+    }
+    // Select direction FIRST (before scanning shows diff info)
+    const direction = options.direction && options.direction !== "sync"
+        ? options.direction
+        : await selectDirection(scope);
+    if (typeof direction === "symbol") {
+        outro("Cancelled.");
+        return { proceed: false, entries: [], scope, direction: "sync" };
+    }
+    const resolvedDirection = direction;
+    const s = spinner();
+    s.start("Scanning for assets...");
+    const scanResults = await scanAllClients(defs, scope);
+    s.stop("Scan complete.");
+    const projectAssets = scope === "global"
+        ? []
+        : scanResults.find((r) => r.client === "project")?.assets ?? [];
+    const globalAssets = scanResults
+        .filter((r) => r.client !== "project" && r.found)
+        .flatMap((r) => r.assets);
+    const allAssets = [...projectAssets, ...globalAssets];
+    if (allAssets.length === 0) {
+        note("No assets found. Create an AGENTS.md or rules to get started.", "Empty");
+        outro("Nothing to sync.");
+        return { proceed: false, entries: [], scope, direction: "sync" };
+    }
+    // Detect conflicts based on direction and scope
+    // Push: project is authoritative, only detect conflicts between global clients
+    // Pull: project is target, detect conflicts between global clients
+    // Sync: detect conflicts between all (but only globalAssets if scope is global)
+    const assetsForConflictDetection = resolvedDirection === "push"
+        ? globalAssets
+        : resolvedDirection === "pull"
+            ? globalAssets
+            : scope === "global"
+                ? globalAssets
+                : allAssets;
+    const conflicts = detectConflicts(assetsForConflictDetection);
+    if (conflicts.length > 0) {
+        console.log();
+        console.log(chalk.bold.yellow(`Found ${conflicts.length} conflict(s):`));
+        for (const conflict of conflicts) {
+            const resolution = await resolveConflict(conflict);
+            if (typeof resolution === "symbol") {
+                outro("Cancelled.");
+                return { proceed: false, entries: [], scope, direction: "sync" };
+            }
+            conflict.resolution = resolution;
+        }
+    }
+    // Now select target clients with diff info
+    const targetClients = await selectTargetClients(scanResults, scope, resolvedDirection, allAssets, conflicts, defs, options);
+    if (typeof targetClients === "symbol" || targetClients.length === 0) {
+        outro("Cancelled.");
+        return { proceed: false, entries: [], scope, direction: "sync" };
+    }
+    const plan = buildPlanFromConflicts(allAssets, conflicts, targetClients, defs, resolvedDirection, options);
+    if (plan.length === 0) {
+        note("All clients are already in sync.", "Up to date");
+        outro("Nothing to do.");
+        return { proceed: false, entries: [], scope, direction: resolvedDirection };
+    }
+    // Review all assets in a unified flow
+    const reviewedPlan = await reviewAllAssets(plan, allAssets);
+    if (typeof reviewedPlan === "symbol") {
+        outro("Cancelled.");
+        return { proceed: false, entries: [], scope, direction: resolvedDirection };
+    }
+    if (reviewedPlan.length === 0) {
+        note("All changes filtered out.", "Nothing to do");
+        outro("Nothing to apply.");
+        return { proceed: false, entries: [], scope, direction: resolvedDirection };
+    }
+    console.log();
+    console.log(chalk.bold("Planned changes:"));
+    for (const entry of reviewedPlan) {
+        const icon = entry.action === "create" ? chalk.green("+") : chalk.blue("~");
+        console.log(`  ${icon} ${entry.targetClient} :: ${entry.targetRelativePath ?? entry.asset.relativePath}`);
+    }
+    console.log();
+    if (options.link === undefined) {
+        const writeMode = await select({
+            message: "How should files be written?",
+            options: [
+                {
+                    value: "symlink",
+                    label: "Symlink",
+                    hint: "Recommended when target can point to the source file directly",
+                },
+                {
+                    value: "copy",
+                    label: "Copy",
+                    hint: "Write independent file copies instead of symlinks",
+                },
+            ],
+            initialValue: "symlink",
+        });
+        if (typeof writeMode === "symbol") {
+            outro("Cancelled.");
+            return {
+                proceed: false,
+                entries: [],
+                scope,
+                direction: resolvedDirection,
+            };
+        }
+        options.link = writeMode === "symlink";
+    }
+    const confirmed = await confirm({
+        message: `Apply ${reviewedPlan.length} change(s)?`,
+        active: "Yes",
+        inactive: "No",
+    });
+    if (!confirmed || typeof confirmed === "symbol") {
+        outro("Cancelled.");
+        return { proceed: false, entries: [], scope, direction: resolvedDirection };
+    }
+    outro("Applying changes...");
+    return {
+        proceed: true,
+        entries: reviewedPlan,
+        scope,
+        direction: resolvedDirection,
+    };
+}
+async function selectScope() {
+    const result = await select({
+        message: "What would you like to sync?",
+        options: [
+            {
+                value: "global",
+                label: "Global configs",
+                hint: "~/.cursor, ~/.claude, ~/.codex, etc.",
+            },
+            {
+                value: "project",
+                label: "Project files",
+                hint: "./AGENTS.md, ./rules/*, etc.",
+            },
+        ],
+    });
+    return result;
+}
+async function selectDirection(scope) {
+    if (scope === "global") {
+        return "sync";
+    }
+    const result = await select({
+        message: "Sync direction:",
+        options: [
+            {
+                value: "push",
+                label: "Project → Global",
+                hint: "Push project rules to all clients",
+            },
+            {
+                value: "pull",
+                label: "Global → Project",
+                hint: "Pull client rules into project",
+            },
+            {
+                value: "sync",
+                label: "Merge all",
+                hint: "Combine and sync everywhere",
+            },
+        ],
+    });
+    return result;
+}
+async function selectTargetClients(scanResults, scope, direction, allAssets, conflicts, defs, options) {
+    // For sync mode, filter based on scope
+    // For push/pull, direction determines which clients are targets
+    const availableClients = scanResults.filter((r) => {
+        if (scope === "global")
+            return r.client !== "project";
+        // For project scope or all, show all clients
+        return true;
+    });
+    // Calculate diff for each client
+    function getDiffLabel(client) {
+        // Calculate what would be created/updated for this client
+        const plan = buildPlanFromConflicts(allAssets, conflicts, [client.client], defs, direction, options);
+        const creates = plan.filter((p) => p.action === "create").length;
+        const updates = plan.filter((p) => p.action === "update").length;
+        if (creates === 0 && updates === 0) {
+            return `${client.assets.length} files, no changes`;
+        }
+        const parts = [];
+        if (creates > 0)
+            parts.push(chalk.green(`+${creates}`));
+        if (updates > 0)
+            parts.push(chalk.blue(`~${updates}`));
+        return `${client.assets.length} files, ${parts.join(" ")}`;
+    }
+    const legend = chalk.dim("(+ new, ~ update)");
+    if (direction === "push") {
+        const globalClients = scanResults.filter((r) => r.client !== "project");
+        const result = await multiselect({
+            message: `Select target clients: ${legend}`,
+            options: globalClients.map((r) => ({
+                value: r.client,
+                label: `${r.displayName} (${getDiffLabel(r)})`,
+            })),
+            initialValues: globalClients.filter((r) => r.found).map((r) => r.client),
+        });
+        return result;
+    }
+    if (direction === "pull") {
+        return ["project"];
+    }
+    const result = await multiselect({
+        message: `Select target clients: ${legend}`,
+        options: availableClients.map((r) => ({
+            value: r.client,
+            label: `${r.displayName} (${getDiffLabel(r)})`,
+        })),
+        initialValues: availableClients.filter((r) => r.found).map((r) => r.client),
+    });
+    return result;
+}
+async function scanAllClients(defs, scope) {
+    const results = [];
+    for (const def of defs) {
+        // Always scan all clients to get full picture for diffing
+        // Scope filtering happens in client selection, not scanning
+        const exists = await fileExists(def.root);
+        if (!exists) {
+            results.push({
+                client: def.name,
+                displayName: def.displayName,
+                found: false,
+                assets: [],
+                root: def.root,
+            });
+            continue;
+        }
+        const assets = await discoverAssets([def], {});
+        results.push({
+            client: def.name,
+            displayName: def.displayName,
+            found: true,
+            assets,
+            root: def.root,
+        });
+    }
+    return results;
+}
+function detectConflicts(assets) {
+    const byKey = new Map();
+    for (const asset of assets) {
+        const key = `${asset.type}::${asset.canonicalPath ?? asset.relativePath}`;
+        const existing = byKey.get(key) ?? [];
+        existing.push(asset);
+        byKey.set(key, existing);
+    }
+    const conflicts = [];
+    for (const [key, versions] of byKey.entries()) {
+        const uniqueHashes = new Set(versions.map((v) => v.hash));
+        if (uniqueHashes.size > 1) {
+            // Sort by modification time, newest first
+            const sorted = versions.slice().sort((a, b) => {
+                const timeA = a.modifiedAt?.getTime() ?? 0;
+                const timeB = b.modifiedAt?.getTime() ?? 0;
+                return timeB - timeA;
+            });
+            conflicts.push({
+                canonicalKey: key,
+                type: versions[0].type,
+                versions: sorted,
+            });
+        }
+    }
+    return conflicts;
+}
+async function resolveConflict(conflict) {
+    const canMerge = conflict.type === "agents" || conflict.type === "mcp";
+    const [, filePath] = conflict.canonicalKey.split("::");
+    // Calculate similarity between first two versions
+    const similarity = conflict.versions.length >= 2
+        ? calculateSimilarity(conflict.versions[0].content, conflict.versions[1].content)
+        : 1;
+    // Auto-resolve if nearly identical (>=95%) - use newest version
+    if (similarity >= 0.95) {
+        conflict.selectedVersion = conflict.versions[0]; // Already sorted by time, newest first
+        return "source";
+    }
+    const similarityLabel = getSimilarityLabel(similarity);
+    const similarityPct = Math.round(similarity * 100);
+    const options = [];
+    // For MCP conflicts, put "Merge" first as the default (most common choice)
+    if (canMerge) {
+        options.push({
+            value: "merge",
+            label: "Merge (combine all servers)",
+            hint: "recommended",
+        });
+    }
+    // Add client version options
+    for (const v of conflict.versions) {
+        const clientLabel = v.client === "project" ? "local (./)" : v.client;
+        options.push({
+            value: v.client,
+            label: `Use ${clientLabel} (${(v.content.length / 1024).toFixed(1)}kb, ${formatRelativeTime(v.modifiedAt)})`,
+        });
+    }
+    // Add rename option for non-mergeable conflicts
+    if (!canMerge) {
+        options.push({
+            value: "rename",
+            label: "Keep both (rename)",
+        });
+    }
+    options.push({
+        value: "skip",
+        label: "Skip (keep as-is)",
+    });
+    const result = await select({
+        message: `${filePath} - ${similarityPct}% ${similarityLabel}`,
+        options,
+    });
+    if (typeof result === "symbol")
+        return result;
+    if (result === "rename")
+        return "rename";
+    if (result === "skip")
+        return "skip";
+    if (result === "merge") {
+        // For MCP merge, immediately ask which servers to include
+        if (conflict.type === "mcp") {
+            const selectedServers = await selectMcpServersForMerge(conflict.versions);
+            if (typeof selectedServers === "symbol")
+                return selectedServers;
+            // Store selected servers in conflict metadata for later use
+            conflict.resolvedContent = selectedServers;
+        }
+        return "merge";
+    }
+    conflict.selectedVersion = conflict.versions.find((v) => v.client === result);
+    const isSource = result === conflict.versions[0].client;
+    return isSource ? "source" : "target";
+}
+/**
+ * Let user select which MCP servers to include in merge
+ */
+async function selectMcpServersForMerge(versions) {
+    // Collect all servers from all versions
+    const serversByName = new Map();
+    for (const version of versions) {
+        const format = detectMcpFormat(version.path);
+        const config = parseMcpConfig(version.content, format);
+        if (!config?.mcpServers)
+            continue;
+        for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+            const list = serversByName.get(serverName) ?? [];
+            list.push({ client: version.client, config: serverConfig });
+            serversByName.set(serverName, list);
+        }
+    }
+    if (serversByName.size === 0) {
+        return "{}"; // Empty config
+    }
+    // Build options for multiselect
+    const options = [];
+    for (const [serverName, sources] of serversByName.entries()) {
+        const sourceClients = sources.map((s) => s.client).join(", ");
+        options.push({
+            value: serverName,
+            label: serverName,
+            hint: `from ${sourceClients}`,
+        });
+    }
+    console.log();
+    const selected = await multiselect({
+        message: "Select MCP servers to include:",
+        options,
+        initialValues: Array.from(serversByName.keys()),
+    });
+    if (typeof selected === "symbol")
+        return selected;
+    // Build merged config with selected servers
+    const mergedServers = {};
+    for (const serverName of selected) {
+        const sources = serversByName.get(serverName);
+        if (sources && sources.length > 0) {
+            // Use first source's config (could add conflict resolution per-server later)
+            mergedServers[serverName] = sources[0].config;
+        }
+    }
+    // Serialize back to JSON
+    return JSON.stringify({ mcpServers: mergedServers }, null, 2);
+}
+function buildPlanFromConflicts(allAssets, conflicts, targetClients, defs, direction, options) {
+    const plan = [];
+    const conflictKeys = new Set(conflicts.map((c) => c.canonicalKey));
+    // Build index of what each client already has (by canonical path and hash)
+    const clientAssets = new Map(); // client -> (canonicalPath -> hash)
+    for (const asset of allAssets) {
+        const canonical = asset.canonicalPath ?? asset.relativePath;
+        if (!clientAssets.has(asset.client)) {
+            clientAssets.set(asset.client, new Map());
+        }
+        clientAssets.get(asset.client).set(canonical, asset.hash);
+    }
+    const resolvedAssets = new Map();
+    for (const asset of allAssets) {
+        const key = `${asset.type}::${asset.canonicalPath ?? asset.relativePath}`;
+        if (conflictKeys.has(key))
+            continue;
+        if (!resolvedAssets.has(key)) {
+            resolvedAssets.set(key, asset);
+        }
+    }
+    for (const conflict of conflicts) {
+        if (conflict.resolution === "skip")
+            continue;
+        if (conflict.resolution === "merge") {
+            let merged;
+            if (conflict.type === "mcp" && conflict.resolvedContent) {
+                // Use pre-selected MCP servers from conflict resolution
+                merged = conflict.resolvedContent;
+            }
+            else if (conflict.type === "mcp") {
+                // Fallback to smart MCP merging
+                const mcpMerged = mergeMcpAssets(conflict.versions);
+                merged =
+                    mcpMerged ??
+                        conflict.versions.map((v) => v.content).join("\n\n---\n\n");
+            }
+            else {
+                // Simple text concatenation for agents files
+                merged = conflict.versions.map((v) => v.content).join("\n\n---\n\n");
+            }
+            const base = conflict.versions[0];
+            resolvedAssets.set(conflict.canonicalKey, {
+                ...base,
+                content: merged,
+                hash: hashContent(merged),
+            });
+        }
+        else if (conflict.resolution === "rename") {
+            for (const version of conflict.versions) {
+                const renamedPath = addClientSuffix(version.canonicalPath ?? version.relativePath, version.client);
+                const renamedKey = `${version.type}::${renamedPath}`;
+                resolvedAssets.set(renamedKey, {
+                    ...version,
+                    canonicalPath: renamedPath,
+                    relativePath: renamedPath,
+                });
+            }
+        }
+        else {
+            const winner = conflict.selectedVersion ??
+                (conflict.resolution === "source"
+                    ? conflict.versions[0]
+                    : conflict.versions[1]);
+            if (winner) {
+                resolvedAssets.set(conflict.canonicalKey, winner);
+            }
+        }
+    }
+    for (const [key, asset] of resolvedAssets.entries()) {
+        for (const clientName of targetClients) {
+            if (clientName === asset.client)
+                continue;
+            // Apply direction filtering
+            if (direction === "push" && asset.client !== "project") {
+                // In push mode, only sync FROM project to global clients
+                continue;
+            }
+            if (direction === "pull" && clientName !== "project") {
+                // In pull mode, only sync TO project
+                continue;
+            }
+            const def = defs.find((d) => d.name === clientName);
+            if (!def)
+                continue;
+            if (shouldSkipTargetAsset(options, clientName, asset)) {
+                continue;
+            }
+            const supportsType = def.assets.some((a) => a.type === asset.type);
+            if (!supportsType)
+                continue;
+            const canonical = asset.canonicalPath ?? asset.relativePath;
+            // Check if target already has this file with same content
+            const targetAssets = clientAssets.get(clientName);
+            if (targetAssets) {
+                const existingHash = targetAssets.get(canonical);
+                if (existingHash === asset.hash) {
+                    // Target already has identical content, skip
+                    continue;
+                }
+            }
+            // Remap path for target client (e.g., MCP configs have different filenames per client)
+            const targetRelative = remapRelativePathForTarget(asset, clientName, canonical, defs);
+            const targetPath = buildTargetAbsolutePath(def.root, targetRelative);
+            plan.push({
+                asset,
+                targetClient: clientName,
+                targetPath,
+                targetRelativePath: targetRelative,
+                action: targetAssets?.has(canonical) ? "update" : "create",
+            });
+        }
+    }
+    return plan;
+}
+function addClientSuffix(filePath, client) {
+    const lastDot = filePath.lastIndexOf(".");
+    if (lastDot === -1) {
+        return `${filePath}-${client}`;
+    }
+    const name = filePath.slice(0, lastDot);
+    const ext = filePath.slice(lastDot);
+    return `${name}-${client}${ext}`;
+}
+const ASSET_TYPE_LABELS = {
+    mcp: "MCP Servers",
+    commands: "Commands",
+    agents: "Agents",
+    rules: "Rules",
+    skills: "Skills",
+    prompts: "Prompts",
+};
+/** Check if asset is the root instructions file (AGENTS.md at root, not in agents/ folder) */
+function isRootInstructionsFile(assetType, canonicalPath) {
+    return assetType === "agents" && canonicalPath === "AGENTS.md";
+}
+/** Format display name for assets */
+function formatAssetDisplayName(assetType, canonicalPath) {
+    // For agents in agents/ folder, strip the prefix for cleaner display
+    if (assetType === "agents" && canonicalPath.startsWith("agents/")) {
+        return canonicalPath.slice(7); // Remove "agents/" prefix
+    }
+    return canonicalPath;
+}
+/**
+ * Unified review flow for all asset types
+ * 1. Resolve conflicts (ask user to pick version when same asset differs)
+ * 2. Show single grouped multiselect for all assets
+ */
+async function reviewAllAssets(plan, allAssets) {
+    if (plan.length === 0)
+        return plan;
+    // Separate MCP from other assets
+    // MCP is handled during conflict resolution (merge step), so we just pass it through
+    const mcpEntries = plan.filter((e) => e.asset.type === "mcp");
+    const otherEntries = plan.filter((e) => e.asset.type !== "mcp");
+    // Process other assets and resolve conflicts
+    const otherResult = await resolveAssetConflicts(otherEntries);
+    if (typeof otherResult === "symbol")
+        return otherResult;
+    const allResolved = [...otherResult.resolved];
+    // If nothing to select (and no MCP), return early
+    if (allResolved.length === 0 && mcpEntries.length === 0) {
+        return [];
+    }
+    // If only MCP entries and no other assets, just return MCP entries
+    if (allResolved.length === 0 && mcpEntries.length > 0) {
+        return mcpEntries;
+    }
+    // If only one non-MCP asset and no conflicts, skip selection
+    if (allResolved.length === 1 && !otherResult.hadConflicts) {
+        // Include MCP entries directly since they're already resolved
+        return [
+            ...mcpEntries,
+            ...otherEntries.filter((e) => e.asset.canonicalPath === allResolved[0].name ||
+                e.asset.relativePath === allResolved[0].name),
+        ];
+    }
+    // Step 3: Separate root instructions (AGENTS.md) from sub-agents
+    const isRootInstructions = (type, name) => type === "agents" &&
+        (name === "AGENTS.md" || name.toUpperCase() === "AGENTS.MD");
+    const byType = new Map();
+    for (const resolved of allResolved) {
+        // Skip root instructions from resolved - we'll handle them separately
+        if (isRootInstructions(resolved.type, resolved.name)) {
+            continue;
+        }
+        const list = byType.get(resolved.type) ?? [];
+        list.push(resolved);
+        byType.set(resolved.type, list);
+    }
+    const selectedResolved = [];
+    // Step 4: Handle root instructions - only if there are plan entries for AGENTS.md
+    const rootPlanEntries = plan.filter((e) => isRootInstructions(e.asset.type, e.asset.canonicalPath ?? e.asset.relativePath));
+    if (rootPlanEntries.length > 0) {
+        // Collect all available sources for AGENTS.md
+        const rootSources = allAssets.filter((a) => a.type === "agents" &&
+            (a.canonicalPath === "AGENTS.md" || a.relativePath === "AGENTS.md"));
+        if (rootSources.length > 1) {
+            // Multiple sources - ask user which to use
+            console.log();
+            // Sort by modification time (most recent first)
+            const sortedSources = [...rootSources].sort((a, b) => {
+                const timeA = a.modifiedAt?.getTime() ?? 0;
+                const timeB = b.modifiedAt?.getTime() ?? 0;
+                return timeB - timeA; // Most recent first
+            });
+            const options = sortedSources.map((a) => {
+                const sizeKb = (a.content.length / 1024).toFixed(1);
+                const relTime = formatRelativeTime(a.modifiedAt);
+                return {
+                    value: a.client,
+                    label: a.client,
+                    hint: `${sizeKb}kb, ${relTime}`,
+                };
+            });
+            options.push({ value: "__skip__", label: "Skip", hint: "" });
+            const sourceChoice = await select({
+                message: "AGENTS.md source:",
+                options,
+                initialValue: sortedSources[0].client, // Default to most recently modified
+            });
+            if (typeof sourceChoice === "symbol")
+                return sourceChoice;
+            if (sourceChoice !== "__skip__") {
+                const selectedSource = rootSources.find((a) => a.client === sourceChoice);
+                if (selectedSource) {
+                    const sizeKb = (selectedSource.content.length / 1024).toFixed(1);
+                    selectedResolved.push({
+                        name: "AGENTS.md",
+                        type: "agents",
+                        version: {
+                            client: selectedSource.client,
+                            asset: selectedSource,
+                            entry: rootPlanEntries[0],
+                        },
+                        label: `${selectedSource.client} (${sizeKb}kb)`,
+                    });
+                }
+            }
+        }
+        else if (rootSources.length === 1) {
+            // Single source - auto-include it (already part of plan)
+            const source = rootSources[0];
+            const sizeKb = (source.content.length / 1024).toFixed(1);
+            selectedResolved.push({
+                name: "AGENTS.md",
+                type: "agents",
+                version: {
+                    client: source.client,
+                    asset: source,
+                    entry: rootPlanEntries[0],
+                },
+                label: `${source.client} (${sizeKb}kb)`,
+            });
+        }
+    }
+    // Step 5: Process each type in a logical order
+    // Note: MCP is NOT included here - it's handled during conflict resolution (merge step)
+    const typeOrder = [
+        "agents",
+        "commands",
+        "prompts",
+        "rules",
+        "skills",
+    ];
+    // Threshold for using searchable multiselect vs regular multiselect
+    // Lower threshold for better UX - searchable is always nicer for lists > 10
+    const SEARCHABLE_THRESHOLD = 10;
+    for (const assetType of typeOrder) {
+        const assets = byType.get(assetType);
+        if (!assets || assets.length === 0)
+            continue;
+        // Deduplicate by name (same command from multiple sources should appear once)
+        const uniqueAssets = new Map();
+        for (const a of assets) {
+            if (!uniqueAssets.has(a.name)) {
+                uniqueAssets.set(a.name, a);
+            }
+        }
+        const deduped = Array.from(uniqueAssets.values());
+        // Sort alphabetically
+        deduped.sort((a, b) => a.name.localeCompare(b.name));
+        console.log();
+        let selectedNames;
+        if (deduped.length > SEARCHABLE_THRESHOLD) {
+            // Use searchable multiselect for large lists
+            const choices = deduped.map((a) => {
+                const displayName = formatAssetDisplayName(assetType, a.name);
+                return {
+                    name: `${displayName} ${chalk.dim(`(${a.label})`)}`,
+                    value: a.name,
+                    short: displayName.split("/").pop() ?? displayName,
+                };
+            });
+            const selected = await checkboxPlus({
+                message: `${ASSET_TYPE_LABELS[assetType]} (${deduped.length}) - type to filter:`,
+                searchable: true,
+                highlight: true,
+                pageSize: 12,
+                default: deduped.map((a) => a.name), // Select all by default
+                source: async (_answers, input) => {
+                    if (!input)
+                        return choices;
+                    const lower = input.toLowerCase();
+                    return choices.filter((c) => c.value.toLowerCase().includes(lower));
+                },
+            });
+            // checkboxPlus returns array of values or throws on cancel
+            if (!Array.isArray(selected)) {
+                return Symbol("cancel");
+            }
+            selectedNames = new Set(selected);
+        }
+        else {
+            // Use regular multiselect for small lists
+            const options = deduped.map((a) => ({
+                value: a.name,
+                label: formatAssetDisplayName(assetType, a.name),
+                hint: a.label,
+            }));
+            const selected = await multiselect({
+                message: `${ASSET_TYPE_LABELS[assetType]} (${deduped.length}):`,
+                options,
+                initialValues: deduped.map((a) => a.name),
+                maxItems: 15,
+            });
+            if (typeof selected === "symbol")
+                return selected;
+            selectedNames = new Set(selected);
+        }
+        for (const asset of deduped) {
+            if (selectedNames.has(asset.name)) {
+                selectedResolved.push(asset);
+            }
+        }
+    }
+    if (selectedResolved.length === 0 && mcpEntries.length === 0) {
+        return [];
+    }
+    // Build final plan for non-MCP entries
+    const finalPlan = buildFinalPlanSimple(selectedResolved, otherEntries);
+    // Add MCP entries directly (already resolved during conflict resolution)
+    return [...mcpEntries, ...finalPlan];
+}
+/**
+ * Build final plan from selected assets (simplified, no MCP handling)
+ */
+function buildFinalPlanSimple(selectedResolved, entries) {
+    const selectedPaths = new Set(selectedResolved.map((r) => `${r.type}::${r.name}`));
+    return entries.filter((e) => {
+        const key = `${e.asset.type}::${e.asset.canonicalPath ?? e.asset.relativePath}`;
+        return selectedPaths.has(key);
+    });
+}
+/**
+ * Resolve MCP server conflicts and prepare for selection
+ */
+async function resolveMcpConflicts(mcpEntries) {
+    const resolved = [];
+    const serverChoices = new Map();
+    let hadConflicts = false;
+    if (mcpEntries.length === 0) {
+        return { resolved, serverChoices, hadConflicts };
+    }
+    // Collect servers by name
+    const serverVersions = new Map();
+    const seenServerClient = new Set();
+    for (const entry of mcpEntries) {
+        const format = detectMcpFormat(entry.asset.path);
+        const config = parseMcpConfig(entry.asset.content, format);
+        if (!config?.mcpServers)
+            continue;
+        for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+            const key = `${serverName}::${entry.asset.client}`;
+            if (seenServerClient.has(key))
+                continue;
+            seenServerClient.add(key);
+            const versions = serverVersions.get(serverName) ?? [];
+            versions.push({
+                client: entry.asset.client,
+                config: serverConfig,
+                entry,
+                format,
+                fullConfig: config,
+            });
+            serverVersions.set(serverName, versions);
+        }
+    }
+    // Process each server
+    for (const [serverName, versions] of serverVersions.entries()) {
+        if (versions.length === 1) {
+            const version = versions[0];
+            const envDisplay = formatEnvForDisplay(version.config.env);
+            serverChoices.set(serverName, version);
+            resolved.push({
+                name: serverName,
+                type: "mcp",
+                version: {
+                    client: version.client,
+                    asset: version.entry.asset,
+                    entry: version.entry,
+                },
+                label: `${version.client} - ${envDisplay}`,
+            });
+        }
+        else {
+            // Check if versions differ
+            const first = versions[0];
+            let hasDifferences = false;
+            for (let i = 1; i < versions.length; i++) {
+                const comparison = compareServerConfigs(first.config, versions[i].config);
+                if (!comparison.same) {
+                    hasDifferences = true;
+                    break;
+                }
+            }
+            if (!hasDifferences) {
+                const envDisplay = formatEnvForDisplay(first.config.env);
+                serverChoices.set(serverName, first);
+                resolved.push({
+                    name: serverName,
+                    type: "mcp",
+                    version: {
+                        client: first.client,
+                        asset: first.entry.asset,
+                        entry: first.entry,
+                    },
+                    label: `${versions.map((v) => v.client).join(", ")} - ${envDisplay}`,
+                });
+            }
+            else {
+                hadConflicts = true;
+                // Show conflict and ask user
+                console.log();
+                console.log(chalk.yellow(`MCP server "${serverName}" differs across clients:`));
+                for (const version of versions) {
+                    const envDisplay = formatEnvForDisplay(version.config.env);
+                    console.log(`  ${chalk.gray(version.client)}: ${version.config.command ?? "?"} - ${chalk.dim(envDisplay)}`);
+                }
+                const versionChoice = await select({
+                    message: `Which "${serverName}" config to use?`,
+                    options: [
+                        ...versions.map((v) => ({
+                            value: v.client,
+                            label: `${v.client} (${v.config.command ?? "?"})`,
+                            hint: formatEnvForDisplay(v.config.env),
+                        })),
+                        { value: "__skip__", label: "Skip this server" },
+                    ],
+                });
+                if (typeof versionChoice === "symbol")
+                    return versionChoice;
+                if (versionChoice !== "__skip__") {
+                    const selected = versions.find((v) => v.client === versionChoice);
+                    if (selected) {
+                        const envDisplay = formatEnvForDisplay(selected.config.env);
+                        serverChoices.set(serverName, selected);
+                        resolved.push({
+                            name: serverName,
+                            type: "mcp",
+                            version: {
+                                client: selected.client,
+                                asset: selected.entry.asset,
+                                entry: selected.entry,
+                            },
+                            label: `${selected.client} - ${envDisplay}`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return { resolved, serverChoices, hadConflicts };
+}
+/**
+ * Resolve conflicts for non-MCP assets
+ */
+async function resolveAssetConflicts(entries) {
+    const resolved = [];
+    let hadConflicts = false;
+    if (entries.length === 0) {
+        return { resolved, hadConflicts };
+    }
+    // Group by type and canonical path (not name, which may differ between clients)
+    const assetVersions = new Map();
+    const seenAssetClient = new Set();
+    for (const entry of entries) {
+        const canonicalPath = entry.asset.canonicalPath ?? entry.asset.relativePath;
+        const key = `${entry.asset.type}::${canonicalPath}::${entry.asset.client}`;
+        if (seenAssetClient.has(key))
+            continue;
+        seenAssetClient.add(key);
+        const mapKey = `${entry.asset.type}::${canonicalPath}`;
+        const versions = assetVersions.get(mapKey) ?? [];
+        versions.push({
+            client: entry.asset.client,
+            asset: entry.asset,
+            entry,
+        });
+        assetVersions.set(mapKey, versions);
+    }
+    // Process each asset
+    for (const [mapKey, versions] of assetVersions.entries()) {
+        const [assetType, ...pathParts] = mapKey.split("::");
+        const canonicalPath = pathParts.join("::");
+        const type = assetType;
+        if (versions.length === 1) {
+            const version = versions[0];
+            const sizeKb = (version.asset.content.length / 1024).toFixed(1);
+            resolved.push({
+                name: canonicalPath,
+                type,
+                version,
+                label: `${version.client} (${sizeKb}kb)`,
+            });
+        }
+        else {
+            // Check if versions differ
+            const first = versions[0];
+            let hasDifferences = false;
+            for (let i = 1; i < versions.length; i++) {
+                if (versions[i].asset.hash !== first.asset.hash) {
+                    hasDifferences = true;
+                    break;
+                }
+            }
+            if (!hasDifferences) {
+                const sizeKb = (first.asset.content.length / 1024).toFixed(1);
+                resolved.push({
+                    name: canonicalPath,
+                    type,
+                    version: first,
+                    label: `${versions.map((v) => v.client).join(", ")} (${sizeKb}kb)`,
+                });
+            }
+            else {
+                hadConflicts = true;
+                // Sort by modification time (most recent first)
+                const sortedVersions = [...versions].sort((a, b) => {
+                    const timeA = a.asset.modifiedAt?.getTime() ?? 0;
+                    const timeB = b.asset.modifiedAt?.getTime() ?? 0;
+                    return timeB - timeA;
+                });
+                // Show conflict
+                console.log();
+                console.log(chalk.yellow(`"${canonicalPath}" (${type}) differs across clients:`));
+                for (const version of sortedVersions) {
+                    const sizeKb = (version.asset.content.length / 1024).toFixed(1);
+                    const relTime = formatRelativeTime(version.asset.modifiedAt);
+                    console.log(`  ${chalk.gray(version.client)}: ${sizeKb}kb, ${relTime}`);
+                }
+                const similarity = calculateSimilarity(sortedVersions[0].asset.content, sortedVersions[1].asset.content);
+                console.log(chalk.dim(`  Similarity: ${Math.round(similarity * 100)}% ${getSimilarityLabel(similarity)}`));
+                const versionChoice = await select({
+                    message: `Which "${canonicalPath}" to use?`,
+                    initialValue: sortedVersions[0].client, // Default to most recently modified
+                    options: [
+                        ...sortedVersions.map((v) => ({
+                            value: v.client,
+                            label: `${v.client} (${(v.asset.content.length / 1024).toFixed(1)}kb)`,
+                            hint: formatRelativeTime(v.asset.modifiedAt),
+                        })),
+                        { value: "__skip__", label: "Skip" },
+                    ],
+                });
+                if (typeof versionChoice === "symbol")
+                    return versionChoice;
+                if (versionChoice !== "__skip__") {
+                    const selected = sortedVersions.find((v) => v.client === versionChoice);
+                    if (selected) {
+                        const sizeKb = (selected.asset.content.length / 1024).toFixed(1);
+                        resolved.push({
+                            name: canonicalPath,
+                            type,
+                            version: selected,
+                            label: `${selected.client} (${sizeKb}kb)`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return { resolved, hadConflicts };
+}
+/**
+ * Build final plan from selected assets
+ */
+function buildFinalPlan(selectedResolved, mcpServerChoices, mcpEntries, otherEntries) {
+    const finalPlan = [];
+    // Handle MCP entries specially - need to rebuild config with selected servers
+    const selectedMcpServers = new Set(selectedResolved.filter((r) => r.type === "mcp").map((r) => r.name));
+    if (selectedMcpServers.size > 0) {
+        // Group MCP entries by target client
+        const mcpByTarget = new Map();
+        for (const entry of mcpEntries) {
+            const entries = mcpByTarget.get(entry.targetClient) ?? [];
+            entries.push(entry);
+            mcpByTarget.set(entry.targetClient, entries);
+        }
+        for (const [targetClient, entries] of mcpByTarget.entries()) {
+            const mergedServers = {};
+            for (const serverName of selectedMcpServers) {
+                const choice = mcpServerChoices.get(serverName);
+                if (choice) {
+                    mergedServers[serverName] = choice.config;
+                }
+            }
+            if (Object.keys(mergedServers).length === 0)
+                continue;
+            const firstEntry = entries[0];
+            const format = detectMcpFormat(firstEntry.asset.path);
+            const baseConfig = parseMcpConfig(firstEntry.asset.content, format) ?? {};
+            const finalConfig = {
+                ...baseConfig,
+                mcpServers: mergedServers,
+            };
+            const serializedContent = serializeMcpConfig(finalConfig, format);
+            finalPlan.push({
+                ...firstEntry,
+                asset: {
+                    ...firstEntry.asset,
+                    content: serializedContent,
+                    hash: hashContent(serializedContent),
+                },
+            });
+        }
+    }
+    // Handle other entries - use canonical paths for matching (r.name is now canonicalPath)
+    const selectedOther = new Map();
+    for (const r of selectedResolved) {
+        if (r.type !== "mcp") {
+            selectedOther.set(`${r.type}::${r.name}`, r);
+        }
+    }
+    const processedTargets = new Set();
+    for (const entry of otherEntries) {
+        const canonicalPath = entry.asset.canonicalPath ?? entry.asset.relativePath;
+        const key = `${entry.asset.type}::${canonicalPath}`;
+        const resolved = selectedOther.get(key);
+        if (!resolved)
+            continue;
+        const targetKey = `${key}::${entry.targetClient}`;
+        if (processedTargets.has(targetKey))
+            continue;
+        processedTargets.add(targetKey);
+        // Use resolved version's content
+        if (entry.asset.client === resolved.version.client) {
+            finalPlan.push(entry);
+        }
+        else {
+            finalPlan.push({
+                ...entry,
+                asset: resolved.version.asset,
+            });
+        }
+    }
+    return finalPlan;
+}
+/**
+ * Validate MCP configs and warn about potential issues
+ */
+async function validateAndWarnMcp(newEntries, originalEntries) {
+    const warnings = [];
+    const errors = [];
+    const missingCommands = new Set();
+    // Validate each new MCP config
+    for (const entry of newEntries) {
+        const format = detectMcpFormat(entry.asset.path);
+        const validation = validateMcpConfig(entry.asset.content, format);
+        for (const err of validation.errors) {
+            errors.push(`${entry.targetClient}: ${err}`);
+        }
+        for (const warn of validation.warnings) {
+            warnings.push(`${entry.targetClient}: ${warn}`);
+        }
+        // Check if commands exist
+        const config = parseMcpConfig(entry.asset.content, format);
+        if (config) {
+            const commands = getMcpCommands(config);
+            for (const cmd of commands) {
+                const exists = await commandExists(cmd);
+                if (!exists) {
+                    missingCommands.add(cmd);
+                }
+            }
+        }
+    }
+    // Check for servers being removed from targets
+    for (const newEntry of newEntries) {
+        const format = detectMcpFormat(newEntry.asset.path);
+        const newConfig = parseMcpConfig(newEntry.asset.content, format);
+        if (!newConfig)
+            continue;
+        // Find original config for same target client
+        for (const origEntry of originalEntries) {
+            if (origEntry.targetClient !== newEntry.targetClient)
+                continue;
+            // Read existing file at target to check what would be removed
+            const existingContent = await readFileSafe(newEntry.targetPath);
+            if (!existingContent)
+                continue;
+            // Use target file's format, not source
+            const targetFormat = detectMcpFormat(newEntry.targetPath);
+            const existingConfig = parseMcpConfig(existingContent, targetFormat);
+            if (!existingConfig)
+                continue;
+            const removed = findRemovedServers(newConfig, existingConfig);
+            for (const serverName of removed) {
+                warnings.push(`${newEntry.targetClient}: server "${serverName}" will be removed`);
+            }
+        }
+    }
+    // Display warnings
+    if (missingCommands.size > 0) {
+        console.log();
+        console.log(chalk.yellow(`Warning: Commands not found in PATH: ${Array.from(missingCommands).join(", ")}`));
+        console.log(chalk.dim("  These MCP servers may not work correctly."));
+    }
+    if (warnings.length > 0) {
+        console.log();
+        console.log(chalk.yellow("Warnings:"));
+        for (const warn of warnings) {
+            console.log(chalk.yellow(`  - ${warn}`));
+        }
+    }
+    if (errors.length > 0) {
+        console.log();
+        console.log(chalk.red("Errors:"));
+        for (const err of errors) {
+            console.log(chalk.red(`  - ${err}`));
+        }
+    }
+}
+//# sourceMappingURL=interactive.js.map