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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @xfe-repo/cli-plugin-ai-rules
 
+## 2.0.9
+
+### Patch Changes
+
+- 修复deploy 优化mcp
+
 ## 2.0.8
 
 ### Patch Changes

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.js

@@ -30,7 +30,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);
@@ -146,7 +147,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;
     }
@@ -340,6 +341,9 @@ 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,

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/package.json

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