@xfe-repo/cli-plugin-ai-rules 2.0.8 → 2.0.10

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @xfe-repo/cli-plugin-ai-rules
 
+## 2.0.10
+
+### Patch Changes
+
+- 优化插件性能
+
+## 2.0.9
+
+### Patch Changes
+
+- 修复deploy 优化mcp
+
 ## 2.0.8
 
 ### Patch Changes

package/README.md

@@ -7,9 +7,22 @@ AI 编码规则同步插件，从远程仓库拉取 AI 编码规则并注入到
 - 声明式 AI 配置管理，从 `xfe.json` 读取 `ai` 配置
 - 远程仓库规则同步，支持本地缓存
 - 多目标格式分发：Markdown、MCP JSON/TOML、技能目录
+- 按 Agent、Sub-Agent、Rules、Skills、MCP 类型独立选择，避免混合列表
 - 智能冲突检测与解决
 - 增量更新规划
 
+## 快速选择
+
+```bash
+xfe rules add --type agent
+xfe rules add --type subagent
+xfe rules add --type rule
+xfe rules add --type skill
+xfe rules add --type mcp
+```
+
+不传 `--type` 时先选择条目类型；传入后直接进入对应条目列表，其他类型的现有配置保持不变。
+
 ## 依赖插件
 
 - `plugin-git`

package/dist/formats/mcp-json.d.ts

@@ -21,5 +21,6 @@ export interface PatchResult {
     hashes: Record<string, string>;
 }
 export declare function patchMcpJsonInjections(config: AiConfig, projectRoot: string, injections: InjectionRegistry): Promise<PatchResult>;
+export declare function stripMcpJsonInjections(content: string): string;
 export declare function getMcpJsonGitignore(target: TargetConfig): string[];
 //# sourceMappingURL=mcp-json.d.ts.map

package/dist/formats/mcp-json.js

@@ -14,6 +14,7 @@ import { getTarget } from '../targets.js';
 import { computeHash } from './shared.js';
 // ─── Constants ──────
 const MCP_SERVER_PREFIX = 'xfe:';
+const getInjectedServerPrefix = (source) => `${MCP_SERVER_PREFIX}${source}:`;
 // ─── Plan ──────
 /**
  * 将 MCP server 项按 target 转换为 PlannedFile
@@ -23,8 +24,8 @@ const MCP_SERVER_PREFIX = 'xfe:';
 export function planMcpJsonFiles(target, items, injections) {
     if (!isMcpJsonTarget(target))
         return [];
-    const syncServers = buildServerEntries(items.filter((i) => i.type === SyncItemType.McpServer));
-    const injectionServers = injections ? buildServerEntries(collectMcpItems(injections)) : {};
+    const syncServers = buildSyncServerEntries(items.filter((i) => i.type === SyncItemType.McpServer));
+    const injectionServers = injections ? buildInjectedServerEntries(injections) : {};
     const servers = { ...syncServers, ...injectionServers };
     if (Object.keys(servers).length === 0)
         return [];
@@ -44,10 +45,11 @@ export async function writeMcpJsonFile(file, projectRoot) {
     await mkdir(path.dirname(absPath), { recursive: true });
     const merged = await mergeWithExisting(absPath, file.content);
     await writeFile(absPath, merged, 'utf-8');
-    return computeHash(merged);
+    return computeHash(stripMcpJsonInjections(merged));
 }
 export async function patchMcpJsonInjections(config, projectRoot, injections) {
-    const servers = buildServerEntries(collectMcpItems(injections));
+    const servers = buildInjectedServerEntries(injections);
+    const injectedPrefixes = collectInjectedServerPrefixes(injections);
     const isEmpty = Object.keys(servers).length === 0;
     let written = 0;
     let removed = 0;
@@ -68,28 +70,48 @@ export async function patchMcpJsonInjections(config, projectRoot, injections) {
         const rootKey = target.mcpRootKey ?? 'mcpServers';
         const parsed = JSON.parse(content);
         const existing = parsed[rootKey] ?? {};
-        const userServers = filterUserServers(existing);
+        const keptServers = filterInjectedServers(existing, injectedPrefixes);
         if (isEmpty) {
-            if (Object.keys(existing).some((k) => k.startsWith(MCP_SERVER_PREFIX))) {
-                parsed[rootKey] = userServers;
+            if (Object.keys(existing).length !== Object.keys(keptServers).length) {
+                parsed[rootKey] = keptServers;
                 await writeFile(absPath, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
                 removed++;
             }
         }
         else {
-            parsed[rootKey] = { ...userServers, ...servers };
+            parsed[rootKey] = { ...keptServers, ...servers };
             await writeFile(absPath, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
             written++;
         }
     }
     return { written, removed, hashes: {} };
 }
+export function stripMcpJsonInjections(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return content;
+    }
+    let changed = false;
+    for (const [rootKey, value] of Object.entries(parsed)) {
+        if (!isRecord(value))
+            continue;
+        const keptServers = filterInjectedServers(value, []);
+        if (Object.keys(keptServers).length === Object.keys(value).length)
+            continue;
+        parsed[rootKey] = keptServers;
+        changed = true;
+    }
+    return changed ? JSON.stringify(parsed, null, 2) + '\n' : content;
+}
 // ─── Gitignore ──────
 export function getMcpJsonGitignore(target) {
     return isMcpJsonTarget(target) ? [target.mcp] : [];
 }
 // ─── Helpers ──────
-function buildServerEntries(items) {
+function buildSyncServerEntries(items) {
     const servers = {};
     for (const item of items) {
         if (!item.serverConfig)
@@ -98,12 +120,23 @@ function buildServerEntries(items) {
     }
     return servers;
 }
+function buildInjectedServerEntries(injections) {
+    const servers = {};
+    for (const [source, items] of injections) {
+        for (const item of items) {
+            if (item.type !== SyncItemType.McpServer || !item.serverConfig)
+                continue;
+            servers[`${getInjectedServerPrefix(source)}${item.id}`] = item.serverConfig;
+        }
+    }
+    return servers;
+}
 function buildMcpJson(target, servers) {
     const rootKey = target.mcpRootKey ?? 'mcpServers';
     return JSON.stringify({ [rootKey]: servers }, null, 2) + '\n';
 }
-function collectMcpItems(injections) {
-    return [...injections.values()].flat().filter((i) => i.type === SyncItemType.McpServer);
+function collectInjectedServerPrefixes(injections) {
+    return [...injections.keys()].map(getInjectedServerPrefix);
 }
 function filterUserServers(servers) {
     const user = {};
@@ -113,6 +146,23 @@ function filterUserServers(servers) {
     }
     return user;
 }
+function filterInjectedServers(servers, injectedPrefixes) {
+    const kept = {};
+    for (const [key, value] of Object.entries(servers)) {
+        if (isInjectedServerKey(key, injectedPrefixes))
+            continue;
+        kept[key] = value;
+    }
+    return kept;
+}
+function isInjectedServerKey(key, injectedPrefixes) {
+    if (injectedPrefixes.some((prefix) => key.startsWith(prefix)))
+        return true;
+    return key.startsWith(MCP_SERVER_PREFIX) && key.slice(MCP_SERVER_PREFIX.length).includes(':');
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
 async function mergeWithExisting(absPath, newContent) {
     if (!existsSync(absPath))
         return newContent;

package/dist/formats/mcp-toml.d.ts

@@ -17,5 +17,6 @@ export interface PatchResult {
     hashes: Record<string, string>;
 }
 export declare function patchMcpTomlInjections(config: AiConfig, projectRoot: string, injections: InjectionRegistry): Promise<PatchResult>;
+export declare function stripMcpTomlInjections(content: string): string;
 export declare function getMcpTomlGitignore(target: TargetConfig): string[];
 //# sourceMappingURL=mcp-toml.d.ts.map

package/dist/formats/mcp-toml.js

@@ -19,6 +19,8 @@ const DEFAULT_SERVER_KEY = 'mcp_server';
 const SERVER_KEY_HASH_LENGTH = 8;
 const MANAGED_BLOCK_BEGIN = '# xfe-ai-rules:mcp:begin';
 const MANAGED_BLOCK_END = '# xfe-ai-rules:mcp:end';
+const INJECTED_BLOCK_BEGIN = '# xfe-ai-rules:mcp-injected:begin';
+const INJECTED_BLOCK_END = '# xfe-ai-rules:mcp-injected:end';
 const TOML_BARE_KEY_PATTERN = /^[A-Za-z0-9_-]+$/;
 const SERVER_KEY_INVALID_CHARS_PATTERN = /[^a-z0-9]+/g;
 const SERVER_KEY_EDGE_UNDERSCORES_PATTERN = /^_+|_+$/g;
@@ -28,16 +30,17 @@ export function planMcpTomlFiles(target, items, injections) {
     if (!isMcpTomlTarget(target))
         return [];
     const syncServers = buildServerEntries(items.filter((i) => i.type === SyncItemType.McpServer));
-    const injectionServers = injections ? buildServerEntries(collectMcpItems(injections)) : {};
-    const servers = { ...syncServers, ...injectionServers };
-    if (Object.keys(servers).length === 0)
+    const injectionServers = injections ? buildInjectedServerEntries(injections) : {};
+    const hasSyncServers = Object.keys(syncServers).length > 0;
+    const hasInjectionServers = Object.keys(injectionServers).length > 0;
+    if (!hasSyncServers && !hasInjectionServers)
         return [];
     return [
         {
             relativePath: target.mcp,
-            content: buildMcpToml(target, servers, true),
+            content: buildMcpToml(target, { syncServers, injectionServers }),
             action: 'write',
-            source: Object.keys(syncServers).length > 0 ? 'sync' : 'injection',
+            source: hasSyncServers ? 'sync' : 'injection',
             format: 'mcp-toml',
         },
     ];
@@ -48,10 +51,10 @@ export async function writeMcpTomlFile(file, projectRoot) {
     await mkdir(path.dirname(absPath), { recursive: true });
     const merged = await mergeWithExisting(absPath, file.content);
     await writeFile(absPath, merged, 'utf-8');
-    return computeHash(merged);
+    return computeHash(stripMcpTomlInjections(merged));
 }
 export async function patchMcpTomlInjections(config, projectRoot, injections) {
-    const servers = buildServerEntries(collectMcpItems(injections));
+    const servers = buildInjectedServerEntries(injections);
     const isEmpty = Object.keys(servers).length === 0;
     let written = 0;
     let removed = 0;
@@ -63,15 +66,13 @@ export async function patchMcpTomlInjections(config, projectRoot, injections) {
         if (!existsSync(absPath)) {
             if (!isEmpty) {
                 await mkdir(path.dirname(absPath), { recursive: true });
-                await writeFile(absPath, buildMcpToml(target, servers, true), 'utf-8');
+                await writeFile(absPath, buildMcpToml(target, { syncServers: {}, injectionServers: servers }), 'utf-8');
                 written++;
             }
             continue;
         }
         const content = await readFile(absPath, 'utf-8');
-        const updated = isEmpty
-            ? removeManagedBlock(content)
-            : mergeTomlContent(content, buildMcpToml(target, servers, true), getRootKey(target));
+        const updated = mergeInjectedTomlContent(content, buildMcpToml(target, { syncServers: {}, injectionServers: servers }), getRootKey(target));
         if (updated === content)
             continue;
         await writeFile(absPath, updated, 'utf-8');
@@ -79,6 +80,10 @@ export async function patchMcpTomlInjections(config, projectRoot, injections) {
     }
     return { written, removed, hashes: {} };
 }
+export function stripMcpTomlInjections(content) {
+    const stripped = removeInjectedBlock(content).trimEnd();
+    return stripped ? stripped + '\n' : '';
+}
 // ─── Gitignore ──────
 export function getMcpTomlGitignore(target) {
     return isMcpTomlTarget(target) ? [target.mcp] : [];
@@ -94,10 +99,22 @@ function buildServerEntries(items) {
     }
     return servers;
 }
-function buildMcpToml(target, servers, includeRootTable) {
+function buildMcpToml(target, options) {
     const rootKey = getRootKey(target);
-    const serverBlocks = Object.entries(servers).map(([name, serverConfig]) => buildServerBlock(rootKey, name, serverConfig));
-    const lines = [MANAGED_BLOCK_BEGIN, includeRootTable ? `[${formatTomlKey(rootKey)}]` : '', ...serverBlocks, MANAGED_BLOCK_END];
+    const blocks = [];
+    const syncEntries = Object.entries(options.syncServers);
+    const injectionEntries = Object.entries(options.injectionServers);
+    if (syncEntries.length > 0) {
+        blocks.push(buildMcpTomlBlock(MANAGED_BLOCK_BEGIN, MANAGED_BLOCK_END, rootKey, syncEntries, true));
+    }
+    if (injectionEntries.length > 0) {
+        blocks.push(buildMcpTomlBlock(INJECTED_BLOCK_BEGIN, INJECTED_BLOCK_END, rootKey, injectionEntries, blocks.length === 0));
+    }
+    return blocks.join('\n');
+}
+function buildMcpTomlBlock(beginMarker, endMarker, rootKey, serverEntries, includeRootTable) {
+    const serverBlocks = serverEntries.map(([name, serverConfig]) => buildServerBlock(rootKey, name, serverConfig));
+    const lines = [beginMarker, includeRootTable ? `[${formatTomlKey(rootKey)}]` : '', ...serverBlocks, endMarker];
     return normalizeTomlLines(lines);
 }
 function buildServerBlock(rootKey, name, serverConfig) {
@@ -115,13 +132,30 @@ async function mergeWithExisting(absPath, newContent) {
     return mergeTomlContent(content, newContent, DEFAULT_ROOT_KEY);
 }
 function mergeTomlContent(content, newContent, rootKey) {
-    const stripped = removeManagedBlock(content);
+    const stripped = removeInjectedBlock(removeManagedBlock(content));
+    const replacement = hasRootScope(stripped, rootKey) ? removeRootTable(newContent, rootKey) : newContent;
+    return appendTomlContent(stripped, replacement);
+}
+function mergeInjectedTomlContent(content, newContent, rootKey) {
+    const stripped = removeInjectedBlock(content);
     const replacement = hasRootScope(stripped, rootKey) ? removeRootTable(newContent, rootKey) : newContent;
-    return spliceMarkerBlock(stripped, MANAGED_BLOCK_BEGIN, MANAGED_BLOCK_END, replacement);
+    return appendTomlContent(stripped, replacement);
 }
 function removeManagedBlock(content) {
     return spliceMarkerBlock(content, MANAGED_BLOCK_BEGIN, MANAGED_BLOCK_END);
 }
+function removeInjectedBlock(content) {
+    return spliceMarkerBlock(content, INJECTED_BLOCK_BEGIN, INJECTED_BLOCK_END);
+}
+function appendTomlContent(content, replacement) {
+    const base = content.trimEnd();
+    const next = replacement.trimEnd();
+    if (!next)
+        return base ? base + '\n' : '';
+    if (!base)
+        return next + '\n';
+    return `${base}\n\n${next}\n`;
+}
 function removeRootTable(content, rootKey) {
     const lines = content.split('\n');
     const rootTableLine = `[${formatTomlKey(rootKey)}]`;
@@ -133,8 +167,17 @@ function hasRootScope(content, rootKey) {
     const rootScopePattern = new RegExp(`^\\s*\\[\\s*${formattedRootKey}(?:\\s*\\]|\\s*\\.)`, 'm');
     return rootScopePattern.test(content);
 }
-function collectMcpItems(injections) {
-    return [...injections.values()].flat().filter((i) => i.type === SyncItemType.McpServer);
+function buildInjectedServerEntries(injections) {
+    const servers = {};
+    for (const [source, items] of injections) {
+        for (const item of items) {
+            if (item.type !== SyncItemType.McpServer || !item.serverConfig)
+                continue;
+            const serverKey = createUniqueServerKey(`${source}-${item.id}`, servers);
+            servers[serverKey] = item.serverConfig;
+        }
+    }
+    return servers;
 }
 function createUniqueServerKey(id, servers) {
     const normalizedKey = normalizeServerKey(id);

package/dist/index.d.ts

@@ -6,7 +6,7 @@
  */
 import type { XfePlugin } from '@xfe-repo/cli-core';
 import type { AiRulesCapability, AiRulesStoreState } from './types.js';
-export { SyncItemType } from './types.js';
+export { RulesAddType, SyncItemType } from './types.js';
 export type { AiRulesCapability, SyncEntry } from './types.js';
 declare const AI_RULES_STORE_INITIAL: AiRulesStoreState;
 declare module '@xfe-repo/cli-core' {

package/dist/index.js

@@ -4,20 +4,39 @@
  * 声明式 AI 配置同步：从 xfe.json 读取 ai 配置，
  * 拉取远程仓库内容，按 target 注册表分发到项目 IDE 配置
  */
-import { aiConfigSchema, rulesAddParameters, rulesSyncParameters, rulesTargetsParameters } from './types.js';
-import { SyncItemType } from './types.js';
+import { aiConfigSchema, rulesAddParameters, rulesSyncParameters, rulesTargetsParameters, RulesAddType, SyncItemType } from './types.js';
 import { planSync, detectConflicts, resolveConflicts, executePlan, checkSyncStatus, applyInjections as applyInjectionsToFiles, } from './pipeline.js';
 import { scanRemoteEntries, loadSelectedItems } from './scanner.js';
 import { fetchCachedRepo } from './repo-cache.js';
 import { getTargetChoices } from './targets.js';
 import { removeStaleSkillDirs } from './formats/skill-dir.js';
-export { SyncItemType } from './types.js';
+export { RulesAddType, SyncItemType } from './types.js';
 // ─── Store ──────
 const AI_RULES_STORE_INITIAL = {
     lastSyncHash: {},
     lastRemoteHash: '',
     lastSyncTime: 0,
 };
+const RULES_ADD_TYPE_CHOICES = [
+    { name: '主 Agent', value: RulesAddType.Agent, description: '选择写入 AGENTS.md 或 CLAUDE.md 的主助手' },
+    { name: 'Sub-Agent', value: RulesAddType.Subagent, description: '选择可按需调用的子助手' },
+    { name: '编码规则 (Rules)', value: RulesAddType.Rule, description: '选择项目编码规范' },
+    { name: 'AI 技能 (Skills)', value: RulesAddType.Skill, description: '选择可复用的 AI 工作流' },
+    { name: 'MCP 服务', value: RulesAddType.Mcp, description: '选择外部工具连接' },
+];
+const ENTRY_TYPE_BY_RULES_ADD_TYPE = {
+    agent: SyncItemType.Agent,
+    subagent: SyncItemType.Agent,
+    rule: SyncItemType.Rule,
+    skill: SyncItemType.Skill,
+    mcp: SyncItemType.McpServer,
+};
+const CONFIG_KEY_BY_RULES_ADD_TYPE = {
+    subagent: 'subagents',
+    rule: 'rules',
+    skill: 'skills',
+    mcp: 'mcpServers',
+};
 // ─── 插件工厂 ──────
 export function aiRulesPlugin() {
     const injectionRegistry = new Map();
@@ -30,7 +49,8 @@ export function aiRulesPlugin() {
                     injectionRegistry.set(source, items);
                 },
                 removeInjectedRules(source) {
-                    injectionRegistry.delete(source);
+                    // 保留 source tombstone，MCP 热清理需要知道要删除哪个动态前缀。
+                    injectionRegistry.set(source, []);
                 },
                 async applyInjections(ctx) {
                     const config = parseAiConfig(ctx);
@@ -68,8 +88,8 @@ export function aiRulesPlugin() {
             });
             hooks.registerCommand({
                 name: 'rules:add',
-                simpleDescription: '选择远程 AI 条目并写入配置',
-                description: '从 aiRules.source 仓库扫描可用的 agent、rule、skill 条目，并把 selectedIds 写回 xfe.json。若 selectedIds 中包含多个 agent，可通过 primaryAgent 指定主 Agent，其余 agent 会写入 subagents。',
+                simpleDescription: '按类型选择远程 AI 条目',
+                description: '按 agent、subagent、rule、skill 或 mcp 类型选择远程条目并更新 xfe.json；传入 type 可跳过类型选择，其他类型的现有配置保持不变。',
                 parameters: rulesAddParameters,
                 execute: (ctx) => executeAddCommand(ctx, injectionRegistry),
             });
@@ -146,7 +166,7 @@ async function executeSyncCommand(ctx, injections) {
         return;
     }
     const hasItems = config.agent || config.subagents.length > 0 || config.rules.length > 0 || config.skills.length > 0 || config.mcpServers.length > 0;
-    if (!hasItems && injections.size === 0) {
+    if (!hasItems && !hasInjectedItems(injections)) {
         ctx.logger.warn('未配置任何 agent/subagents/rules/skills/mcpServers，请先运行 xfe rules add');
         return;
     }
@@ -195,40 +215,17 @@ async function executeAddCommand(ctx, injections) {
         const cachePath = await fetchCachedRepo(ctx, git, config);
         const entries = await scanRemoteEntries(cachePath);
         spinner.stop();
-        const currentSelectedIds = collectSelectedIds(config);
-        const selectedIds = await promptItemSelection(ctx, entries, currentSelectedIds);
-        // 分类选中项
-        const selectedAgents = entries.filter((e) => e.type === SyncItemType.Agent && selectedIds.has(e.id));
-        let agentId;
-        if (selectedAgents.length === 1) {
-            agentId = selectedAgents[0].id;
-        }
-        else if (selectedAgents.length > 1) {
-            agentId = await promptMainAgentSelection(ctx, selectedAgents, config.agent);
-        }
-        const { rules, skills, mcpServers, subagents } = classifySelectedIds(entries, selectedIds, agentId);
+        const selectionType = await promptRulesAddType(ctx);
+        const selectionPatch = await promptTypeSelection(ctx, entries, config, selectionType);
+        if (!selectionPatch)
+            return;
         ctx.store.setPluginState('xfe', {
             aiRules: {
                 ...ctx.store.getState().xfe?.aiRules,
-                agent: agentId,
-                subagents,
-                rules,
-                skills,
-                mcpServers,
+                ...selectionPatch,
             },
         });
-        const parts = [
-            agentId && `agent: ${agentId}`,
-            subagents.length > 0 && `${subagents.length} subagents`,
-            rules.length > 0 && `${rules.length} rules`,
-            skills.length > 0 && `${skills.length} skills`,
-            mcpServers.length > 0 && `${mcpServers.length} mcp-servers`,
-        ].filter(Boolean);
-        ctx.logger.success(`已写入 xfe.json: ${parts.join(', ') || '无选择'}`);
-        if (parts.length === 0) {
-            ctx.logger.warn('未选择任何条目，配置已清空');
-            return;
-        }
+        logSelectionResult(ctx, selectionType, selectionPatch);
         const { sync } = await ctx.prompt.ask({
             type: 'confirm',
             name: 'sync',
@@ -270,34 +267,68 @@ async function executeTargetsCommand(ctx) {
     }
 }
 // ─── 交互提示 ──────
-async function promptMainAgentSelection(ctx, selectedAgents, currentAgent) {
-    const choices = selectedAgents.map((entry) => ({
-        name: entry.id,
-        value: entry.id,
-        description: entry.description,
-    }));
-    const { primaryAgent } = await ctx.prompt.ask({
+async function promptRulesAddType(ctx) {
+    const { type } = await ctx.prompt.ask({
         type: 'list',
+        name: 'type',
+        message: '选择要配置的 AI 条目类型:',
+        choices: RULES_ADD_TYPE_CHOICES,
+    });
+    if (Object.values(RulesAddType).includes(type))
+        return type;
+    throw new Error(`不支持的 AI 条目类型: ${String(type)}`);
+}
+async function promptTypeSelection(ctx, entries, config, selectionType) {
+    const selectableEntries = getSelectableEntries(entries, selectionType, config.agent);
+    if (selectableEntries.length === 0) {
+        ctx.logger.warn(`${getRulesAddTypeLabel(selectionType)} 暂无可选项`);
+        return undefined;
+    }
+    if (selectionType === RulesAddType.Agent) {
+        const agent = await promptPrimaryAgentSelection(ctx, selectableEntries, config.agent);
+        return {
+            agent,
+            subagents: config.subagents.filter((id) => id !== agent),
+        };
+    }
+    const configKey = CONFIG_KEY_BY_RULES_ADD_TYPE[selectionType];
+    if (!configKey)
+        return undefined;
+    const selectedIds = await promptItemSelection(ctx, selectableEntries, new Set(config[configKey]), selectionType);
+    const selectionPatch = {};
+    selectionPatch[configKey] = [...selectedIds];
+    return selectionPatch;
+}
+async function promptPrimaryAgentSelection(ctx, agents, currentAgent) {
+    const choices = [
+        { name: '不配置主 Agent', value: '', description: '清除当前主 Agent' },
+        ...agents.map((entry) => ({
+            name: entry.id,
+            value: entry.id,
+            description: getEntryChoiceDescription(entry),
+        })),
+    ];
+    const { primaryAgent } = await ctx.prompt.ask({
+        type: 'search-list',
         name: 'primaryAgent',
-        message: '已选择多个 Agent，请指定主 Agent（输出到 AGENTS.md/CLAUDE.md）:',
+        message: '选择主 Agent:',
         choices,
-        default: currentAgent || undefined,
+        default: currentAgent ?? '',
     });
     return primaryAgent || undefined;
 }
-async function promptItemSelection(ctx, entries, currentIds) {
-    if (entries.length === 0)
-        return new Set();
+async function promptItemSelection(ctx, entries, currentIds, selectionType) {
     const choices = entries.map((entry) => {
         const description = getEntryChoiceDescription(entry);
         return {
-            name: `[${entry.type}] ${entry.id}`,
+            name: entry.id,
             value: entry.id,
             description,
             short: entry.id,
         };
     });
-    const message = currentIds.size > 0 ? `选择 AI 规则 (当前已选 ${currentIds.size} 项):` : '选择 AI 规则:';
+    const label = getRulesAddTypeLabel(selectionType);
+    const message = currentIds.size > 0 ? `选择 ${label} (当前已选 ${currentIds.size} 项):` : `选择 ${label}:`;
     const { selectedIds = [] } = await ctx.prompt.ask({
         type: 'search-checkbox',
         name: 'selectedIds',
@@ -308,31 +339,22 @@ async function promptItemSelection(ctx, entries, currentIds) {
     return new Set(selectedIds);
 }
 // ─── Helpers ──────
-function classifySelectedIds(entries, selectedIds, agentId) {
-    const rules = [];
-    const skills = [];
-    const mcpServers = [];
-    const subagents = [];
-    for (const entry of entries) {
-        if (!selectedIds.has(entry.id))
-            continue;
-        switch (entry.type) {
-            case SyncItemType.Rule:
-                rules.push(entry.id);
-                break;
-            case SyncItemType.Skill:
-                skills.push(entry.id);
-                break;
-            case SyncItemType.McpServer:
-                mcpServers.push(entry.id);
-                break;
-            case SyncItemType.Agent:
-                if (entry.id !== agentId)
-                    subagents.push(entry.id);
-                break;
-        }
+function getSelectableEntries(entries, selectionType, currentAgent) {
+    const entryType = ENTRY_TYPE_BY_RULES_ADD_TYPE[selectionType];
+    return entries.filter((entry) => entry.type === entryType && !(selectionType === RulesAddType.Subagent && entry.id === currentAgent));
+}
+function getRulesAddTypeLabel(selectionType) {
+    return RULES_ADD_TYPE_CHOICES.find(({ value }) => value === selectionType)?.name ?? selectionType;
+}
+function logSelectionResult(ctx, selectionType, selectionPatch) {
+    const label = getRulesAddTypeLabel(selectionType);
+    if (selectionType === RulesAddType.Agent) {
+        ctx.logger.success(selectionPatch.agent ? `已更新主 Agent: ${selectionPatch.agent}` : '已清除主 Agent');
+        return;
     }
-    return { rules, skills, mcpServers, subagents };
+    const configKey = CONFIG_KEY_BY_RULES_ADD_TYPE[selectionType];
+    const selectedCount = configKey ? (selectionPatch[configKey]?.length ?? 0) : 0;
+    ctx.logger.success(`已更新 ${label}: ${selectedCount} 项`);
 }
 function collectSelectedIds(config) {
     const ids = [...config.subagents, ...config.rules, ...config.skills, ...config.mcpServers];
@@ -340,11 +362,11 @@ function collectSelectedIds(config) {
         ids.push(config.agent);
     return new Set(ids);
 }
+function hasInjectedItems(injections) {
+    return [...injections.values()].some((items) => items.length > 0);
+}
 function getEntryChoiceDescription(entry) {
-    const descriptions = [
-        entry.description,
-        entry.appliesTo?.length ? `适用: ${entry.appliesTo.join(', ')}` : undefined,
-    ].filter(Boolean);
+    const descriptions = [entry.description, entry.appliesTo?.length ? `适用: ${entry.appliesTo.join(', ')}` : undefined].filter(Boolean);
     if (descriptions.length === 0)
         return undefined;
     return descriptions.join(' · ');

package/dist/pipeline.js

@@ -8,12 +8,13 @@
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { McpConfigFormat } from './types.js';
 import { getTarget } from './targets.js';
 import { getCachePath, hasCachedRepo } from './repo-cache.js';
 import { computeHash, spliceMarkerBlock } from './formats/shared.js';
 import { planMarkdownFiles, detectMarkdownConflict, writeMarkdownFile, patchMarkdownInjections, getMarkdownGitignore, stripInjectedSections, removeStaleInjectedFiles, } from './formats/agent-md.js';
-import { planMcpJsonFiles, writeMcpJsonFile, patchMcpJsonInjections, getMcpJsonGitignore } from './formats/mcp-json.js';
-import { planMcpTomlFiles, writeMcpTomlFile, patchMcpTomlInjections, getMcpTomlGitignore } from './formats/mcp-toml.js';
+import { planMcpJsonFiles, writeMcpJsonFile, patchMcpJsonInjections, getMcpJsonGitignore, stripMcpJsonInjections } from './formats/mcp-json.js';
+import { planMcpTomlFiles, writeMcpTomlFile, patchMcpTomlInjections, getMcpTomlGitignore, stripMcpTomlInjections } from './formats/mcp-toml.js';
 import { planSkillDirs, writeSkillDir, patchSkillDirInjections } from './formats/skill-dir.js';
 // ─── Constants ──────
 const GITIGNORE_BLOCK_START = '# xfe-ai-rules (auto-generated, do not edit)';
@@ -138,7 +139,7 @@ export async function checkSyncStatus(ctx, config) {
         if (!existsSync(absPath))
             return false;
         const content = await readFile(absPath, 'utf-8');
-        if (computeHash(stripInjectedSections(content)) !== expectedHash)
+        if (computeHash(stripRuntimeInjections(config, relativePath, content)) !== expectedHash)
             return false;
     }
     return true;
@@ -174,4 +175,16 @@ async function updateGitignore(projectRoot, entries) {
     const updated = spliceMarkerBlock(content, GITIGNORE_BLOCK_START, GITIGNORE_BLOCK_END, newBlock);
     await writeFile(gitignorePath, updated, 'utf-8');
 }
+function stripRuntimeInjections(config, relativePath, content) {
+    for (const targetId of config.targets) {
+        const target = getTarget(targetId);
+        if (!target || target.mcp !== relativePath)
+            continue;
+        if ((target.mcpFormat ?? McpConfigFormat.Json) === McpConfigFormat.Json)
+            return stripMcpJsonInjections(content);
+        if (target.mcpFormat === McpConfigFormat.Toml)
+            return stripMcpTomlInjections(content);
+    }
+    return stripInjectedSections(content);
+}
 //# sourceMappingURL=pipeline.js.map

package/dist/types.d.ts

@@ -29,7 +29,15 @@ export declare enum McpConfigFormat {
 export declare const rulesTargetsParameters: z.ZodObject<{
     targets: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof SyncTarget>>>;
 }, z.core.$strip>;
+export declare enum RulesAddType {
+    Agent = "agent",
+    Subagent = "subagent",
+    Rule = "rule",
+    Skill = "skill",
+    Mcp = "mcp"
+}
 export declare const rulesAddParameters: z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<typeof RulesAddType>>;
     selectedIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     primaryAgent: z.ZodOptional<z.ZodString>;
     sync: z.ZodOptional<z.ZodBoolean>;

package/dist/types.js

@@ -32,12 +32,18 @@ const syncTargetSchema = z.enum(SyncTarget);
 export const rulesTargetsParameters = z.object({
     targets: z.array(syncTargetSchema).optional().describe('需要同步注入的 IDE 目标 ID，可选值: copilot、codex、cursor、claude-code'),
 });
+export var RulesAddType;
+(function (RulesAddType) {
+    RulesAddType["Agent"] = "agent";
+    RulesAddType["Subagent"] = "subagent";
+    RulesAddType["Rule"] = "rule";
+    RulesAddType["Skill"] = "skill";
+    RulesAddType["Mcp"] = "mcp";
+})(RulesAddType || (RulesAddType = {}));
 export const rulesAddParameters = z.object({
-    selectedIds: z
-        .array(z.string())
-        .optional()
-        .describe('需要写入 aiRules 的远程条目 ID 列表，可混合 agent、rule、skill；MCP 调用时应直接传入'),
-    primaryAgent: z.string().optional().describe('当 selectedIds 中包含多个 agent 时，指定主 Agent ID；其余 agent 会写入 subagents'),
+    type: z.enum(RulesAddType).optional().describe('需要配置的条目类型，可选值: agent、subagent、rule、skill、mcp'),
+    selectedIds: z.array(z.string()).optional().describe('type 为 subagent、rule、skill 或 mcp 时，需要写入 aiRules 的远程条目 ID 列表'),
+    primaryAgent: z.string().optional().describe('type 为 agent 时，需要写入 aiRules.agent 的主 Agent ID'),
     sync: z.boolean().optional().describe('写入配置后立即执行同步'),
 });
 export const rulesSyncParameters = z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfe-repo/cli-plugin-ai-rules",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "description": "XFE AI Rules plugin - sync AI coding rules from remote repo to IDE configs",
   "type": "module",
   "main": "./dist/index.js",