@xfe-repo/cli-plugin-ai-rules 2.0.4 → 2.0.5

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @xfe-repo/cli-plugin-ai-rules
 
+## 2.0.5
+
+### Patch Changes
+
+- 优化插件
+- Updated dependencies
+  - @xfe-repo/cli-plugin-git@2.0.5
+  - @xfe-repo/cli-core@2.0.6
+
 ## 2.0.4
 
 ### Patch Changes

package/README.md

@@ -6,7 +6,7 @@ AI 编码规则同步插件，从远程仓库拉取 AI 编码规则并注入到
 
 - 声明式 AI 配置管理，从 `xfe.json` 读取 `ai` 配置
 - 远程仓库规则同步，支持本地缓存
-- 多目标格式分发：Markdown、MCP JSON、技能目录
+- 多目标格式分发：Markdown、MCP JSON/TOML、技能目录
 - 智能冲突检测与解决
 - 增量更新规划
 

package/dist/formats/mcp-json.js

@@ -9,7 +9,7 @@
 import { existsSync } from 'node:fs';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import path from 'node:path';
-import { SyncItemType } from '../types.js';
+import { McpConfigFormat, SyncItemType } from '../types.js';
 import { getTarget } from '../targets.js';
 import { computeHash } from './shared.js';
 // ─── Constants ──────
@@ -21,7 +21,7 @@ const MCP_SERVER_PREFIX = 'xfe:';
  * 可选注入项合并到同一 JSON 文件
  */
 export function planMcpJsonFiles(target, items, injections) {
-    if (!target.mcp)
+    if (!isMcpJsonTarget(target))
         return [];
     const syncServers = buildServerEntries(items.filter((i) => i.type === SyncItemType.McpServer));
     const injectionServers = injections ? buildServerEntries(collectMcpItems(injections)) : {};
@@ -53,7 +53,7 @@ export async function patchMcpJsonInjections(config, projectRoot, injections) {
     let removed = 0;
     for (const targetId of config.targets) {
         const target = getTarget(targetId);
-        if (!target?.mcp)
+        if (!target || !isMcpJsonTarget(target))
             continue;
         const absPath = path.join(projectRoot, target.mcp);
         if (!existsSync(absPath)) {
@@ -86,7 +86,7 @@ export async function patchMcpJsonInjections(config, projectRoot, injections) {
 }
 // ─── Gitignore ──────
 export function getMcpJsonGitignore(target) {
-    return target.mcp ? [target.mcp] : [];
+    return isMcpJsonTarget(target) ? [target.mcp] : [];
 }
 // ─── Helpers ──────
 function buildServerEntries(items) {
@@ -129,4 +129,7 @@ async function mergeWithExisting(absPath, newContent) {
     existing[rootKey] = { ...userServers, ...newParsed[rootKey] };
     return JSON.stringify(existing, null, 2) + '\n';
 }
+function isMcpJsonTarget(target) {
+    return Boolean(target.mcp) && (target.mcpFormat ?? McpConfigFormat.Json) === McpConfigFormat.Json;
+}
 //# sourceMappingURL=mcp-json.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * MCP TOML 格式模块
+ *
+ * 处理 Codex `.codex/config.toml` 的 MCP 配置写入：
+ * - 使用标记块隔离 xfe 管理的 server 条目
+ * - 将 server id 规范化为 Codex 可识别的 snake_case 表名
+ * - 写入时保留用户自定义 TOML 配置，仅替换 xfe 管理块
+ * - 新建文件时生成 Codex 兼容的 `[mcp_servers]` 配置结构
+ */
+import type { AiConfig, InjectionRegistry, PlannedFile, SyncEntry } from '../types.js';
+import type { TargetConfig } from '../targets.js';
+export declare function planMcpTomlFiles(target: TargetConfig, items: SyncEntry[], injections?: InjectionRegistry): PlannedFile[];
+export declare function writeMcpTomlFile(file: PlannedFile, projectRoot: string): Promise<string>;
+export interface PatchResult {
+    written: number;
+    removed: number;
+    hashes: Record<string, string>;
+}
+export declare function patchMcpTomlInjections(config: AiConfig, projectRoot: string, injections: InjectionRegistry): Promise<PatchResult>;
+export declare function getMcpTomlGitignore(target: TargetConfig): string[];
+//# sourceMappingURL=mcp-toml.d.ts.map

package/dist/formats/mcp-toml.js

@@ -0,0 +1,211 @@
+/**
+ * MCP TOML 格式模块
+ *
+ * 处理 Codex `.codex/config.toml` 的 MCP 配置写入：
+ * - 使用标记块隔离 xfe 管理的 server 条目
+ * - 将 server id 规范化为 Codex 可识别的 snake_case 表名
+ * - 写入时保留用户自定义 TOML 配置，仅替换 xfe 管理块
+ * - 新建文件时生成 Codex 兼容的 `[mcp_servers]` 配置结构
+ */
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { McpConfigFormat, SyncItemType } from '../types.js';
+import { getTarget } from '../targets.js';
+import { computeHash, spliceMarkerBlock } from './shared.js';
+// ─── Constants ──────
+const DEFAULT_ROOT_KEY = 'mcp_servers';
+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 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;
+const SERVER_KEY_NUMBER_PREFIX_PATTERN = /^[0-9]/;
+// ─── Plan ──────
+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)
+        return [];
+    return [
+        {
+            relativePath: target.mcp,
+            content: buildMcpToml(target, servers, true),
+            action: 'write',
+            source: Object.keys(syncServers).length > 0 ? 'sync' : 'injection',
+            format: 'mcp-toml',
+        },
+    ];
+}
+// ─── Write ──────
+export async function writeMcpTomlFile(file, projectRoot) {
+    const absPath = path.join(projectRoot, file.relativePath);
+    await mkdir(path.dirname(absPath), { recursive: true });
+    const merged = await mergeWithExisting(absPath, file.content);
+    await writeFile(absPath, merged, 'utf-8');
+    return computeHash(merged);
+}
+export async function patchMcpTomlInjections(config, projectRoot, injections) {
+    const servers = buildServerEntries(collectMcpItems(injections));
+    const isEmpty = Object.keys(servers).length === 0;
+    let written = 0;
+    let removed = 0;
+    for (const targetId of config.targets) {
+        const target = getTarget(targetId);
+        if (!target || !isMcpTomlTarget(target))
+            continue;
+        const absPath = path.join(projectRoot, target.mcp);
+        if (!existsSync(absPath)) {
+            if (!isEmpty) {
+                await mkdir(path.dirname(absPath), { recursive: true });
+                await writeFile(absPath, buildMcpToml(target, servers, true), 'utf-8');
+                written++;
+            }
+            continue;
+        }
+        const content = await readFile(absPath, 'utf-8');
+        const updated = isEmpty
+            ? removeManagedBlock(content)
+            : mergeTomlContent(content, buildMcpToml(target, servers, true), getRootKey(target));
+        if (updated === content)
+            continue;
+        await writeFile(absPath, updated, 'utf-8');
+        isEmpty ? removed++ : written++;
+    }
+    return { written, removed, hashes: {} };
+}
+// ─── Gitignore ──────
+export function getMcpTomlGitignore(target) {
+    return isMcpTomlTarget(target) ? [target.mcp] : [];
+}
+// ─── Helpers ──────
+function buildServerEntries(items) {
+    const servers = {};
+    for (const item of items) {
+        if (!item.serverConfig)
+            continue;
+        const serverKey = createUniqueServerKey(item.id, servers);
+        servers[serverKey] = item.serverConfig;
+    }
+    return servers;
+}
+function buildMcpToml(target, servers, includeRootTable) {
+    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];
+    return normalizeTomlLines(lines);
+}
+function buildServerBlock(rootKey, name, serverConfig) {
+    if (!isTomlTableValue(serverConfig))
+        return `[${formatTomlKey(rootKey)}.${formatTomlKey(name)}]`;
+    const assignments = Object.entries(serverConfig)
+        .filter((entry) => isSerializableTomlValue(entry[1]))
+        .map(([key, value]) => `${formatTomlKey(key)} = ${formatTomlValue(value)}`);
+    return [`[${formatTomlKey(rootKey)}.${formatTomlKey(name)}]`, ...assignments].join('\n');
+}
+async function mergeWithExisting(absPath, newContent) {
+    if (!existsSync(absPath))
+        return newContent;
+    const content = await readFile(absPath, 'utf-8');
+    return mergeTomlContent(content, newContent, DEFAULT_ROOT_KEY);
+}
+function mergeTomlContent(content, newContent, rootKey) {
+    const stripped = removeManagedBlock(content);
+    const replacement = hasRootScope(stripped, rootKey) ? removeRootTable(newContent, rootKey) : newContent;
+    return spliceMarkerBlock(stripped, MANAGED_BLOCK_BEGIN, MANAGED_BLOCK_END, replacement);
+}
+function removeManagedBlock(content) {
+    return spliceMarkerBlock(content, MANAGED_BLOCK_BEGIN, MANAGED_BLOCK_END);
+}
+function removeRootTable(content, rootKey) {
+    const lines = content.split('\n');
+    const rootTableLine = `[${formatTomlKey(rootKey)}]`;
+    const filtered = lines.filter((line) => line.trim() !== rootTableLine);
+    return filtered.join('\n').replace(`${MANAGED_BLOCK_BEGIN}\n\n\n`, `${MANAGED_BLOCK_BEGIN}\n\n`);
+}
+function hasRootScope(content, rootKey) {
+    const formattedRootKey = escapeRegExp(formatTomlKey(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 createUniqueServerKey(id, servers) {
+    const normalizedKey = normalizeServerKey(id);
+    if (!hasServerKey(servers, normalizedKey))
+        return normalizedKey;
+    const hashSuffix = computeHash(id).slice(0, SERVER_KEY_HASH_LENGTH);
+    const keyWithHash = `${normalizedKey}_${hashSuffix}`;
+    if (!hasServerKey(servers, keyWithHash))
+        return keyWithHash;
+    let index = 2;
+    while (hasServerKey(servers, `${keyWithHash}_${index}`)) {
+        index++;
+    }
+    return `${keyWithHash}_${index}`;
+}
+function normalizeServerKey(id) {
+    const snakeCaseKey = id.toLowerCase().replace(SERVER_KEY_INVALID_CHARS_PATTERN, '_').replace(SERVER_KEY_EDGE_UNDERSCORES_PATTERN, '');
+    const fallbackKey = snakeCaseKey || `${DEFAULT_SERVER_KEY}_${computeHash(id).slice(0, SERVER_KEY_HASH_LENGTH)}`;
+    if (SERVER_KEY_NUMBER_PREFIX_PATTERN.test(fallbackKey))
+        return `${DEFAULT_SERVER_KEY}_${fallbackKey}`;
+    return fallbackKey;
+}
+function hasServerKey(servers, key) {
+    return Object.prototype.hasOwnProperty.call(servers, key);
+}
+function getRootKey(target) {
+    return target.mcpRootKey ?? DEFAULT_ROOT_KEY;
+}
+function isMcpTomlTarget(target) {
+    return Boolean(target.mcp) && target.mcpFormat === McpConfigFormat.Toml;
+}
+function isTomlTableValue(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isSerializableTomlValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return value.every(isSerializableTomlValue);
+    if (isTomlTableValue(value))
+        return Object.values(value).every(isSerializableTomlValue);
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    return ['string', 'boolean'].includes(typeof value);
+}
+function formatTomlValue(value) {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value))
+        return `[${value.map(formatTomlValue).join(', ')}]`;
+    if (isTomlTableValue(value))
+        return `{ ${formatTomlInlineTable(value)} }`;
+    throw new Error(`无法序列化 TOML 值: ${String(value)}`);
+}
+function formatTomlInlineTable(value) {
+    return Object.entries(value)
+        .filter((entry) => isSerializableTomlValue(entry[1]))
+        .map(([key, item]) => `${formatTomlKey(key)} = ${formatTomlValue(item)}`)
+        .join(', ');
+}
+function formatTomlKey(key) {
+    if (TOML_BARE_KEY_PATTERN.test(key))
+        return key;
+    return JSON.stringify(key);
+}
+function normalizeTomlLines(lines) {
+    return lines.filter((line) => line !== '').join('\n\n') + '\n';
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=mcp-toml.js.map

package/dist/index.js

@@ -271,10 +271,11 @@ async function executeTargetsCommand(ctx) {
 }
 // ─── 交互提示 ──────
 async function promptMainAgentSelection(ctx, selectedAgents, currentAgent) {
-    const choices = selectedAgents.map((entry) => {
-        const desc = entry.description ? ` — ${entry.description}` : '';
-        return { name: `${entry.id}${desc}`, value: entry.id };
-    });
+    const choices = selectedAgents.map((entry) => ({
+        name: entry.id,
+        value: entry.id,
+        description: entry.description,
+    }));
     const { primaryAgent } = await ctx.prompt.ask({
         type: 'list',
         name: 'primaryAgent',
@@ -288,11 +289,11 @@ async function promptItemSelection(ctx, entries, currentIds) {
     if (entries.length === 0)
         return new Set();
     const choices = entries.map((entry) => {
-        const desc = entry.description ? ` — ${entry.description}` : '';
-        const scope = entry.appliesTo?.length ? ` [${entry.appliesTo.join(', ')}]` : '';
+        const description = getEntryChoiceDescription(entry);
         return {
-            name: `[${entry.type}] ${entry.id}${desc}${scope}`,
+            name: `[${entry.type}] ${entry.id}`,
             value: entry.id,
+            description,
             short: entry.id,
         };
     });
@@ -339,6 +340,15 @@ function collectSelectedIds(config) {
         ids.push(config.agent);
     return new Set(ids);
 }
+function getEntryChoiceDescription(entry) {
+    const descriptions = [
+        entry.description,
+        entry.appliesTo?.length ? `适用: ${entry.appliesTo.join(', ')}` : undefined,
+    ].filter(Boolean);
+    if (descriptions.length === 0)
+        return undefined;
+    return descriptions.join(' · ');
+}
 function getAiRulesState(ctx) {
     return (ctx.store.getState()['ai-rules'] ?? AI_RULES_STORE_INITIAL);
 }

package/dist/pipeline.js

@@ -13,10 +13,17 @@ 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 { planSkillDirs, writeSkillDir, patchSkillDirInjections } from './formats/skill-dir.js';
 // ─── Constants ──────
 const GITIGNORE_BLOCK_START = '# xfe-ai-rules (auto-generated, do not edit)';
 const GITIGNORE_BLOCK_END = '# end xfe-ai-rules';
+const MCP_CONFIG_FORMATS = new Set(['mcp-json', 'mcp-toml']);
+const FILE_WRITERS = {
+    markdown: writeMarkdownFile,
+    'mcp-json': writeMcpJsonFile,
+    'mcp-toml': writeMcpTomlFile,
+};
 // ─── Pipeline Step 1: Plan ──────
 export function planSync(config, items, injections) {
     const files = [];
@@ -28,9 +35,11 @@ export function planSync(config, items, injections) {
             continue;
         files.push(...planMarkdownFiles(target, items, injections));
         files.push(...planMcpJsonFiles(target, items, injections));
+        files.push(...planMcpTomlFiles(target, items, injections));
         skillDirs.push(...planSkillDirs(target, items));
         getMarkdownGitignore(target).forEach((e) => gitignoreEntries.add(e));
         getMcpJsonGitignore(target).forEach((e) => gitignoreEntries.add(e));
+        getMcpTomlGitignore(target).forEach((e) => gitignoreEntries.add(e));
     }
     return { files, skillDirs, gitignoreEntries: [...gitignoreEntries] };
 }
@@ -42,8 +51,8 @@ export async function detectConflicts(plan, projectRoot, lastHashes) {
             updatedFiles.push(file);
             continue;
         }
-        // MCP JSON 使用前缀隔离，不做冲突检测
-        if (file.format === 'mcp-json') {
+        // MCP 配置使用前缀/标记块隔离，不做冲突检测
+        if (MCP_CONFIG_FORMATS.has(file.format)) {
             updatedFiles.push(file);
             continue;
         }
@@ -92,7 +101,7 @@ export async function executePlan(plan, projectRoot) {
             skipped++;
             continue;
         }
-        const hash = file.format === 'mcp-json' ? await writeMcpJsonFile(file, projectRoot) : await writeMarkdownFile(file, projectRoot);
+        const hash = await FILE_WRITERS[file.format](file, projectRoot);
         written++;
         if (file.source === 'sync') {
             fileHashes[file.relativePath] = hash;
@@ -136,10 +145,11 @@ export async function checkSyncStatus(ctx, config) {
 export async function applyInjections(ctx, config, injections) {
     const mdResult = await patchMarkdownInjections(config, ctx.projectRoot, injections);
     const mcpResult = await patchMcpJsonInjections(config, ctx.projectRoot, injections);
+    const mcpTomlResult = await patchMcpTomlInjections(config, ctx.projectRoot, injections);
     const skillResult = await patchSkillDirInjections(config, ctx.projectRoot, injections);
-    const written = mdResult.written + mcpResult.written + skillResult.written;
-    const removed = mdResult.removed + mcpResult.removed;
-    const allHashes = { ...mdResult.hashes, ...mcpResult.hashes };
+    const written = mdResult.written + mcpResult.written + mcpTomlResult.written + skillResult.written;
+    const removed = mdResult.removed + mcpResult.removed + mcpTomlResult.removed;
+    const allHashes = { ...mdResult.hashes, ...mcpResult.hashes, ...mcpTomlResult.hashes };
     // 删除历史注入独立文件
     const storeState = (ctx.store.getState()['ai-rules'] ?? {});
     const prevPaths = new Set(Object.keys(storeState.lastInjectedHash ?? {}));

package/dist/targets.d.ts

@@ -4,7 +4,7 @@
  * 内置 IDE target 配置：输出路径、命名规则
  * 路径模板中包含 {id} 的为独立文件，否则为合并文件
  */
-import { SyncItemType, SyncTarget } from './types.js';
+import { McpConfigFormat, SyncItemType, SyncTarget } from './types.js';
 import type { SyncEntry } from './types.js';
 export interface TargetConfig {
     id: SyncTarget;
@@ -14,6 +14,7 @@ export interface TargetConfig {
     subagents: string;
     skills: string;
     mcp?: string;
+    mcpFormat?: McpConfigFormat;
     mcpRootKey?: string;
     gitignoreEntries: string[];
 }

package/dist/targets.js

@@ -4,7 +4,7 @@
  * 内置 IDE target 配置：输出路径、命名规则
  * 路径模板中包含 {id} 的为独立文件，否则为合并文件
  */
-import { SyncItemType, SyncTarget } from './types.js';
+import { McpConfigFormat, SyncItemType, SyncTarget } from './types.js';
 // ─── Target 注册表 ──────
 const TARGET_REGISTRY = {
     [SyncTarget.Copilot]: {
@@ -15,6 +15,7 @@ const TARGET_REGISTRY = {
         subagents: '.github/agents/{id}.md',
         skills: '.github/skills/{id}/SKILL.md',
         mcp: '.vscode/mcp.json',
+        mcpFormat: McpConfigFormat.Json,
         mcpRootKey: 'servers',
         gitignoreEntries: ['AGENTS.md', '.github/', '.vscode/'],
     },
@@ -26,6 +27,7 @@ const TARGET_REGISTRY = {
         subagents: '.cursor/agents/{id}.md',
         skills: '.cursor/skills/{id}/SKILL.md',
         mcp: '.cursor/mcp.json',
+        mcpFormat: McpConfigFormat.Json,
         mcpRootKey: 'mcpServers',
         gitignoreEntries: ['AGENTS.md', '.cursor/'],
     },
@@ -37,6 +39,7 @@ const TARGET_REGISTRY = {
         subagents: '.claude/agents/{id}.md',
         skills: '.claude/skills/{id}/SKILL.md',
         mcp: '.claude/mcp.json',
+        mcpFormat: McpConfigFormat.Json,
         mcpRootKey: 'mcpServers',
         gitignoreEntries: ['CLAUDE.md', '.claude/'],
     },
@@ -47,6 +50,9 @@ const TARGET_REGISTRY = {
         rules: 'AGENTS.md',
         subagents: '.codex/agents/{id}.md',
         skills: '.codex/skills/{id}/SKILL.md',
+        mcp: '.codex/config.toml',
+        mcpFormat: McpConfigFormat.Toml,
+        mcpRootKey: 'mcp_servers',
         gitignoreEntries: ['AGENTS.md', '.codex/'],
     },
 };

package/dist/types.d.ts

@@ -22,6 +22,10 @@ export declare enum SyncTarget {
     Cursor = "cursor",
     ClaudeCode = "claude-code"
 }
+export declare enum McpConfigFormat {
+    Json = "json",
+    Toml = "toml"
+}
 export declare const rulesTargetsParameters: z.ZodObject<{
     targets: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof SyncTarget>>>;
 }, z.core.$strip>;
@@ -60,7 +64,7 @@ export interface SyncEntry {
     /** MCP server 原始配置对象（仅 McpServer 类型使用） */
     serverConfig?: Record<string, unknown>;
 }
-export type FileFormat = 'markdown' | 'mcp-json';
+export type FileFormat = 'markdown' | 'mcp-json' | 'mcp-toml';
 /** 计划写入的 skill 目录 */
 export interface SkillDirPlan {
     id: string;

package/dist/types.js

@@ -23,6 +23,11 @@ export var SyncTarget;
     SyncTarget["Cursor"] = "cursor";
     SyncTarget["ClaudeCode"] = "claude-code";
 })(SyncTarget || (SyncTarget = {}));
+export var McpConfigFormat;
+(function (McpConfigFormat) {
+    McpConfigFormat["Json"] = "json";
+    McpConfigFormat["Toml"] = "toml";
+})(McpConfigFormat || (McpConfigFormat = {}));
 const syncTargetSchema = z.enum(SyncTarget);
 export const rulesTargetsParameters = z.object({
     targets: z.array(syncTargetSchema).optional().describe('需要同步注入的 IDE 目标 ID，可选值: copilot、codex、cursor、claude-code'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfe-repo/cli-plugin-ai-rules",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "XFE AI Rules plugin - sync AI coding rules from remote repo to IDE configs",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,8 +9,8 @@
     "fs-extra": "^11.3.0",
     "gray-matter": "^4.0.3",
     "zod": "^4.3.6",
-    "@xfe-repo/cli-core": "2.0.5",
-    "@xfe-repo/cli-plugin-git": "2.0.4"
+    "@xfe-repo/cli-core": "2.0.6",
+    "@xfe-repo/cli-plugin-git": "2.0.5"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",