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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @xfe-repo/cli-plugin-ai-rules
 
+## 2.0.10
+
+### Patch Changes
+
+- 优化插件性能
+
 ## 2.0.9
 
 ### 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/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();
@@ -69,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),
             });
@@ -196,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',
@@ -271,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',
@@ -309,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];
@@ -345,10 +366,7 @@ 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/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.9",
+  "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",