postar-pipe-mcp 0.0.2 → 1.0.0

package/dist/server.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { ZodOptional as ZodOptional$2, z } from "zod";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import require$$0, { existsSync, readdirSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import require$$0$1, { resolve as resolve$3, dirname, join } from "path";
 import require$$0$2 from "child_process";
-import require$$0$1, { dirname, resolve as resolve$3 } from "path";
-import require$$0, { existsSync, readdirSync, readFileSync } from "fs";
 import process$1 from "node:process";
 import { PassThrough } from "node:stream";
 import { fileURLToPath } from "url";
@@ -21197,15 +21198,75 @@ async function handleProxiedTool(name, args) {
 const skillCache = /* @__PURE__ */ new Map();
 const skillMetadataCache = /* @__PURE__ */ new Map();
 let remoteSkillsList = null;
+function parseSkillSource(url, index) {
+  const rawUrl = url.replace("/tree/", "/raw/").replace(/\/$/, "");
+  const match = url.match(/\/([^\/]+)\/[^\/]+\/tree\//);
+  const name = match ? match[1] : `source-${index}`;
+  return {
+    name,
+    baseUrl: rawUrl,
+    originalUrl: url
+  };
+}
+function parseCommandLineArgs() {
+  const result = {};
+  const skillUrls = [];
+  for (let i = 0; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg === "--skill-url" && i + 1 < process.argv.length) {
+      skillUrls.push(process.argv[i + 1]);
+    } else if (arg.startsWith("--skill-url=")) {
+      skillUrls.push(arg.split("=")[1]);
+    }
+    if (arg.startsWith("--skills-urls=")) {
+      result.skillsUrls = arg.split("=")[1];
+    } else if (arg === "--skills-urls" && i + 1 < process.argv.length) {
+      result.skillsUrls = process.argv[i + 1];
+    }
+    if (arg.startsWith("--skills-url=")) {
+      result.skillsUrl = arg.split("=")[1];
+    } else if (arg === "--skills-url" && i + 1 < process.argv.length) {
+      result.skillsUrl = process.argv[i + 1];
+    }
+  }
+  if (skillUrls.length > 0) {
+    result.skillUrls = skillUrls;
+  }
+  return result;
+}
 function getSkillsConfig() {
-  const skillsUrl = process.env.SKILLS_URL;
+  const cliArgs = parseCommandLineArgs();
+  if (cliArgs.skillUrls && cliArgs.skillUrls.length > 0) {
+    const sources = cliArgs.skillUrls.map((url, index) => parseSkillSource(url.trim(), index)).filter((source) => source.originalUrl.length > 0);
+    if (sources.length > 0) {
+      return {
+        source: "remote",
+        sources,
+        baseUrl: sources[0].baseUrl,
+        originalUrl: sources[0].originalUrl
+      };
+    }
+  }
+  const skillsUrls = cliArgs.skillsUrls || process.env.SKILLS_URLS;
+  if (skillsUrls) {
+    const sources = skillsUrls.split(",").map((url, index) => parseSkillSource(url.trim(), index)).filter((source) => source.originalUrl.length > 0);
+    if (sources.length > 0) {
+      return {
+        source: "remote",
+        sources,
+        baseUrl: sources[0].baseUrl,
+        originalUrl: sources[0].originalUrl
+      };
+    }
+  }
+  const skillsUrl = cliArgs.skillsUrl || process.env.SKILLS_URL;
   if (skillsUrl) {
-    const rawUrl = skillsUrl.replace("/tree/", "/raw/").replace(/\/$/, "");
+    const source = parseSkillSource(skillsUrl, 0);
     return {
       source: "remote",
-      baseUrl: rawUrl,
-      originalUrl: skillsUrl
-      // 保留原始 URL 用于解析
+      sources: [source],
+      baseUrl: source.baseUrl,
+      originalUrl: source.originalUrl
     };
   }
   return {
@@ -21283,21 +21344,52 @@ async function fetchRemoteSkillsFromDirectory(config2) {
     return [];
   }
 }
+const skillSourceMap = /* @__PURE__ */ new Map();
 async function fetchRemoteSkillsList(config2) {
   if (remoteSkillsList) {
     return remoteSkillsList;
   }
   const skillsListEnv = process.env.SKILLS_LIST;
   if (skillsListEnv) {
-    const skills2 = skillsListEnv.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-    remoteSkillsList = skills2;
-    console.error(`[SKILL-LOADER] 从环境变量加载 skills: ${skills2.join(", ")}`);
-    return skills2;
+    const skills = skillsListEnv.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    remoteSkillsList = skills;
+    console.error(`[SKILL-LOADER] 从环境变量加载 skills: ${skills.join(", ")}`);
+    return skills;
+  }
+  console.error(`[SKILL-LOADER] 未配置 SKILLS_LIST,自动遍历所有远程目录...`);
+  const allSkills = [];
+  skillSourceMap.clear();
+  if (config2.sources && config2.sources.length > 0) {
+    for (const source of config2.sources) {
+      console.error(`[SKILL-LOADER] 扫描源: ${source.name} (${source.originalUrl})`);
+      const sourceConfig = {
+        source: "remote",
+        baseUrl: source.baseUrl,
+        originalUrl: source.originalUrl
+      };
+      const skills = await fetchRemoteSkillsFromDirectory(sourceConfig);
+      console.error(`[SKILL-LOADER] 源 ${source.name} 发现 skills: ${skills.join(", ")}`);
+      for (const skillName of skills) {
+        if (!allSkills.includes(skillName)) {
+          allSkills.push(skillName);
+        }
+        skillSourceMap.set(skillName, source);
+      }
+    }
+  } else if (config2.baseUrl && config2.originalUrl) {
+    const skills = await fetchRemoteSkillsFromDirectory(config2);
+    for (const skillName of skills) {
+      allSkills.push(skillName);
+      skillSourceMap.set(skillName, {
+        name: "default",
+        baseUrl: config2.baseUrl,
+        originalUrl: config2.originalUrl
+      });
+    }
   }
-  console.error(`[SKILL-LOADER] 未配置 SKILLS_LIST,自动遍历远程目录...`);
-  const skills = await fetchRemoteSkillsFromDirectory(config2);
-  remoteSkillsList = skills;
-  return skills;
+  console.error(`[SKILL-LOADER] 汇总所有 skills: ${allSkills.join(", ")}`);
+  remoteSkillsList = allSkills;
+  return allSkills;
 }
 async function loadRemoteSkillContent(skillName, baseUrl) {
   const skillUrl = `${baseUrl}/${skillName}/SKILL.md`;
@@ -21357,8 +21449,20 @@ async function getAvailableSkills() {
 }
 async function loadSkillContent(skillName) {
   const config2 = getSkillsConfig();
-  if (config2.source === "remote" && config2.baseUrl) {
-    return loadRemoteSkillContent(skillName, config2.baseUrl);
+  if (config2.source === "remote") {
+    const source = skillSourceMap.get(skillName);
+    if (source) {
+      console.error(`[SKILL-LOADER] 从源 ${source.name} 加载 skill: ${skillName}`);
+      return loadRemoteSkillContent(skillName, source.baseUrl);
+    }
+    if (config2.sources && config2.sources.length > 0) {
+      const firstSource = config2.sources[0];
+      console.error(`[SKILL-LOADER] 未找到来源映射，使用默认源 ${firstSource.name} 加载: ${skillName}`);
+      return loadRemoteSkillContent(skillName, firstSource.baseUrl);
+    }
+    if (config2.baseUrl) {
+      return loadRemoteSkillContent(skillName, config2.baseUrl);
+    }
   }
   const skillPath = resolve$3(getSkillsDir(), skillName, "SKILL.md");
   try {
@@ -21376,7 +21480,7 @@ async function getSkillContent(skillName) {
   }
   return skillCache.get(skillName);
 }
-function parseFrontmatter(content) {
+async function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
   if (!match) {
@@ -21384,30 +21488,37 @@ function parseFrontmatter(content) {
   }
   const frontmatterText = match[1];
   const body = match[2];
-  const metadata2 = {};
-  const lines = frontmatterText.split("\n");
-  for (const line of lines) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex > 0) {
-      const key = line.slice(0, colonIndex).trim();
-      let value = line.slice(colonIndex + 1).trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        value = value.slice(1, -1);
+  try {
+    const yaml = await import("js-yaml");
+    const metadata2 = yaml.load(frontmatterText) || {};
+    return { metadata: metadata2, body };
+  } catch {
+    const metadata2 = {};
+    const lines = frontmatterText.split("\n");
+    for (const line of lines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0 && !line.startsWith("-") && !line.startsWith(" ")) {
+        const key = line.slice(0, colonIndex).trim();
+        let value = line.slice(colonIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        metadata2[key] = value;
       }
-      metadata2[key] = value;
     }
+    return { metadata: metadata2, body };
   }
-  return { metadata: metadata2, body };
 }
 async function getSkillMetadata(skillName) {
   if (!skillMetadataCache.has(skillName)) {
     const content = await getSkillContent(skillName);
-    const { metadata: metadata2 } = parseFrontmatter(content);
+    const { metadata: metadata2 } = await parseFrontmatter(content);
     const metadataObj = {
       name: metadata2.name || skillName,
       description: metadata2.description || `${skillName} skill`,
       constraint: metadata2.constraint,
       version: metadata2.version,
+      tools: metadata2.tools || [],
       ...metadata2
       // 包含其他自定义字段
     };
@@ -21419,6 +21530,184 @@ async function getAllSkillsMetadata() {
   const skills = await getAvailableSkills();
   return Promise.all(skills.map((skillName) => getSkillMetadata(skillName)));
 }
+let globalTempSkillDir = null;
+function setTempSkillDir(tempDir) {
+  globalTempSkillDir = tempDir;
+}
+function getTempSkillDir() {
+  return globalTempSkillDir;
+}
+function getSkillResourceFiles(skillName) {
+  if (!globalTempSkillDir) {
+    return [];
+  }
+  const skillDir = resolve$3(globalTempSkillDir, skillName);
+  if (!existsSync(skillDir)) {
+    return [];
+  }
+  try {
+    return readdirSync(skillDir).filter((name) => name !== "SKILL.md");
+  } catch {
+    return [];
+  }
+}
+function getWorkspaceSkillDir(skillName) {
+  return resolve$3(globalTempSkillDir, skillName);
+}
+function copyDirectorySync(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = resolve$3(src, entry.name);
+    const destPath = resolve$3(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectorySync(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+async function downloadRemoteFile(url, targetPath) {
+  try {
+    const headers = {};
+    const gitlabToken = process.env.GITLAB_TOKEN;
+    if (gitlabToken) {
+      headers["PRIVATE-TOKEN"] = gitlabToken;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      console.error(`[SKILL-LOADER] 下载远程文件失败: ${url} - ${response.status}`);
+      return false;
+    }
+    const content = await response.text();
+    if (content.trim().startsWith("<!DOCTYPE") || content.trim().startsWith("<html")) {
+      console.error(`[SKILL-LOADER] 下载远程文件返回了 HTML 页面: ${url}`);
+      return false;
+    }
+    mkdirSync(dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, content, "utf-8");
+    return true;
+  } catch (error2) {
+    console.error(`[SKILL-LOADER] 下载远程文件异常: ${url}`, error2);
+    return false;
+  }
+}
+async function listRemoteSkillFiles(skillName, source) {
+  try {
+    const parsed = await parseGitLabUrl(source.originalUrl);
+    if (!parsed) {
+      console.error(`[SKILL-LOADER] 无法解析远程 URL: ${source.originalUrl}`);
+      return [];
+    }
+    const { host, projectPath, ref: ref2, path: basePath } = parsed;
+    const skillPath = basePath ? `${basePath}/${skillName}` : skillName;
+    const encodedProjectPath = encodeURIComponent(projectPath);
+    const apiUrl = `${host}/api/v4/projects/${encodedProjectPath}/repository/tree?ref=${encodeURIComponent(ref2)}&path=${encodeURIComponent(skillPath)}`;
+    const headers = {};
+    const gitlabToken = process.env.GITLAB_TOKEN;
+    if (gitlabToken) {
+      headers["PRIVATE-TOKEN"] = gitlabToken;
+    }
+    const response = await fetch(apiUrl, { headers });
+    if (!response.ok) {
+      console.error(`[SKILL-LOADER] 获取远程文件列表失败: ${response.status}`);
+      return [];
+    }
+    const items2 = await response.json();
+    return items2.filter((item) => item.type === "blob" && item.name !== "SKILL.md").map((item) => item.name);
+  } catch (error2) {
+    console.error(`[SKILL-LOADER] 获取远程文件列表异常:`, error2);
+    return [];
+  }
+}
+async function extractRemoteSkillResourcesToTempDir(skillName, source) {
+  const extractedPaths = [];
+  const files = await listRemoteSkillFiles(skillName, source);
+  if (files.length === 0) {
+    console.error(`[SKILL-LOADER] 远程 Skill ${skillName} 没有资源文件`);
+    return [];
+  }
+  console.error(`[SKILL-LOADER] 发现远程 Skill ${skillName} 的资源文件: ${files.join(", ")}`);
+  for (const fileName of files) {
+    const fileUrl = `${source.baseUrl}/${skillName}/${fileName}`;
+    const targetDir = getWorkspaceSkillDir(skillName);
+    const targetPath = resolve$3(targetDir, fileName);
+    const success = await downloadRemoteFile(fileUrl, targetPath);
+    if (success) {
+      extractedPaths.push(targetPath);
+      console.error(`[SKILL-LOADER] 已下载远程资源: ${skillName}/${fileName} -> ${targetPath}`);
+    } else {
+      console.error(`[SKILL-LOADER] 下载远程资源失败: ${skillName}/${fileName}`);
+    }
+  }
+  return extractedPaths;
+}
+async function extractSkillResourcesToTempDir(skillName) {
+  const config2 = getSkillsConfig();
+  if (config2.source === "remote") {
+    const source = skillSourceMap.get(skillName);
+    if (source) {
+      console.error(`[SKILL-LOADER] 从远程源 ${source.name} 提取 Skill ${skillName} 的资源`);
+      return extractRemoteSkillResourcesToTempDir(skillName, source);
+    }
+    if (config2.sources && config2.sources.length > 0) {
+      console.error(`[SKILL-LOADER] 使用默认远程源提取 Skill ${skillName} 的资源`);
+      return extractRemoteSkillResourcesToTempDir(skillName, config2.sources[0]);
+    }
+    console.error(`[SKILL-LOADER] 远程模式下找不到 Skill ${skillName} 的源配置`);
+    return [];
+  }
+  const skillDir = getSkillsDir();
+  const sourceDir = resolve$3(skillDir, skillName);
+  if (!existsSync(sourceDir)) {
+    console.error(`[SKILL-LOADER] Skill 目录不存在: ${sourceDir}`);
+    return [];
+  }
+  const extractedPaths = [];
+  try {
+    const entries = readdirSync(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "SKILL.md") {
+        continue;
+      }
+      const sourcePath = resolve$3(sourceDir, entry.name);
+      const targetDir = getWorkspaceSkillDir(skillName);
+      const targetPath = resolve$3(targetDir, entry.name);
+      try {
+        mkdirSync(dirname(targetPath), { recursive: true });
+        if (entry.isDirectory()) {
+          copyDirectorySync(sourcePath, targetPath);
+        } else {
+          copyFileSync(sourcePath, targetPath);
+        }
+        extractedPaths.push(targetPath);
+        console.error(`[SKILL-LOADER] 已提取资源: ${skillName}/${entry.name} -> ${targetPath}`);
+      } catch (error2) {
+        console.error(`[SKILL-LOADER] 提取资源失败: ${skillName}/${entry.name}`, error2);
+      }
+    }
+  } catch (error2) {
+    console.error(`[SKILL-LOADER] 读取 Skill 目录失败: ${sourceDir}`, error2);
+  }
+  return extractedPaths;
+}
+async function extractAllSkillResourcesToTempDir(tempDir) {
+  setTempSkillDir(tempDir);
+  const skills = await getAvailableSkills();
+  const allExtracted = {};
+  console.error(`[SKILL-LOADER] 开始提取 ${skills.length} 个 Skill 的资源到临时目录: ${tempDir}`);
+  for (const skillName of skills) {
+    const paths = await extractSkillResourcesToTempDir(skillName);
+    if (paths.length > 0) {
+      allExtracted[skillName] = paths;
+    }
+  }
+  const totalCount = Object.values(allExtracted).flat().length;
+  console.error(`[SKILL-LOADER] 资源提取完成，共 ${totalCount} 个文件`);
+  return allExtracted;
+}
+const FIXED_SKILL_DIR = join(tmpdir(), "mcp-pipe-skills");
+let skillResourcesDir = FIXED_SKILL_DIR;
 async function createServer() {
   const server = new McpServer({
     name: "mcp-pipe",
@@ -21440,6 +21729,27 @@ async function createServer() {
         const skillLoaded = skills.includes(metadata2.name);
         const skillMetadata = await getSkillMetadata(metadata2.name);
         const skillContent = await getSkillContent(metadata2.name);
+        let injectedContent = skillContent;
+        const currentTempDir = getTempSkillDir();
+        if (currentTempDir) {
+          const skillResourceDir = join(currentTempDir, metadata2.name);
+          const resourceFiles = getSkillResourceFiles(metadata2.name);
+          let resourceNotice = `> 📁 **本 Skill 的资源文件**:
+`;
+          if (resourceFiles.length > 0) {
+            for (const file of resourceFiles) {
+              resourceNotice += `>   - \`${join(skillResourceDir, file)}\`
+`;
+            }
+          } else {
+            resourceNotice += ">   （无额外资源文件）\n";
+          }
+          resourceNotice += `> 
+> 💡 **提示**: 当 Skill 文档中提到读取配置文件或模板文件时，请使用上述完整路径
+
+`;
+          injectedContent = resourceNotice + skillContent;
+        }
         return {
           content: [{
             type: "text",
@@ -21447,7 +21757,7 @@ async function createServer() {
 
 📖 ${skillMetadata.description}
 
-${skillContent}
+${injectedContent}
 
 ---
 ${skillLoaded ? "✅" : "❌"} Skills 加载状态: ${skillLoaded ? `${metadata2.name} skill 已加载` : `${metadata2.name} skill 未加载`}
@@ -21511,8 +21821,34 @@ async function preloadSkills() {
     }
   }
 }
+function cleanupSkillDir() {
+  if (existsSync(skillResourcesDir)) {
+    try {
+      rmSync(skillResourcesDir, { recursive: true, force: true });
+      console.error(`[MCP-PIPE] Skill 资源目录已清理: ${skillResourcesDir}`);
+    } catch (error2) {
+      console.error(`[MCP-PIPE] 清理 Skill 资源目录失败: ${skillResourcesDir}`, error2);
+    }
+  }
+}
 async function main() {
+  process.on("exit", cleanupSkillDir);
+  process.on("SIGINT", () => {
+    console.error("[MCP-PIPE] 收到 SIGINT，正在清理...");
+    cleanupSkillDir();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    console.error("[MCP-PIPE] 收到 SIGTERM，正在清理...");
+    cleanupSkillDir();
+    process.exit(0);
+  });
+  if (!existsSync(skillResourcesDir)) {
+    mkdirSync(skillResourcesDir, { recursive: true });
+  }
+  console.error(`[MCP-PIPE] Skill 资源目录: ${skillResourcesDir}`);
   await preloadSkills();
+  await extractAllSkillResourcesToTempDir(skillResourcesDir);
   initMCPClients();
   const server = await createServer();
   const transport = new StdioServerTransport();
@@ -21521,5 +21857,6 @@ async function main() {
 }
 main().catch((error2) => {
   console.error("[MCP-PIPE] 致命错误:", error2);
+  cleanupSkillDir();
   process.exit(1);
 });

package/dist/skills/cd/SKILL.md

@@ -20,7 +20,7 @@ version: 1.0.0
 
 ## 说明
 
-本指令用于直接触发 Jenkins 构建，执行服务部署。与 `/ci` 命令不同，`/cd` 只负责部署，不负责代码合并。适用于仅需重新部署或部署特定分支的场景。
+本指令用于直接触发 Jenkins 构建，执行服务部署。与 `/ci` 命令不同，`/cd` 只负责部署。适用于仅需重新部署或部署特定分支的场景。
 
 > **⚠️ 重要约束**：
 > - 当 `config.yaml` 中设置 `jenkins.is_current_branch: false` 时，**严禁执行任何本地git命令**获取分支信息
@@ -83,7 +83,7 @@ version: 1.0.0
 
 > **⚠️ 配置读取优先级**：按以下顺序读取配置，找到即停止：
 > 1. 项目根目录的 `config.yaml`
-> 2. 本 Skill 同级目录的 `template.yaml`
+> 2. 默认模版配置 `./template.yaml`
 >
 > **必须每次重新读取**：禁止使用上下文缓存，每次执行时都要重新读取配置。
 >
@@ -104,10 +104,14 @@ version: 1.0.0
    - 若用户传入了 `branch:xxx`，提取指定分支名，**跳过分支获取**
    - 若未指定分支，继续下一步
 
-3. **智能发现 Jenkins Job（优先执行）**：
-   - 对每个环境，首先尝试在 `config.yaml` 中查找对应配置
-   - **若配置存在**：使用配置中的 `fullname` 和 MCP 名称，进入参数处理流程（步骤 2）
+3. **查找 Jenkins Job（优先执行）**：
+   - 对每个环境，按以下顺序查找配置：
+     1. 首先在 `config.yaml` 中查找对应配置
+     2. 若 `config.yaml` 中不存在，在 `template.yaml` 中查找对应配置
+   - **若配置存在（config.yaml 或 template.yaml）**：使用配置中的 `fullname` 和 MCP 名称，直接进入参数处理流程（步骤 2），**无需用户确认**
    - **若配置不存在（智能发现模式）**：
+     - **智能发现定义**：只有 AI 主动去 Jenkins 上查找 Job 才算智能发现
+     - template.yaml 中的配置属于**预配置**，不算智能发现
      1. **扫描所有 Jenkins MCP**：
         - 读取 `mcp.json` 配置，识别所有可用的 Jenkins MCP（名称包含 `jenkins` 的 MCP）
         - 按 MCP 名称排序，优先尝试 `jenkins`，然后是 `jenkins-prod`、`jenkins-test` 等其他 Jenkins MCP
@@ -472,11 +476,3 @@ params:
 /cd dev-api,dev-admin branch:release/v1.0
 ```
 
-## 与 /ci 命令的区别
-
-| 命令 | 功能 | 适用场景 |
-|------|------|----------|
-| `/ci` | MR 合并 + 可选 Jenkins 构建 | 需要代码合并并部署 |
-| `/cd` | 直接 Jenkins 构建 | 仅需部署，无需合并 |
-
-> **建议**：日常开发使用 `/ci` 完成合并+部署；若只想重新部署或部署特定分支，使用 `/cd`。

package/dist/skills/ci/SKILL.md

@@ -55,7 +55,11 @@ version: 1.0.0
 ### 0. 分支存在性检查逻辑
 
 创建 MR 前执行：
-- 调用 `mcp_gitlab_browse_refs` (action=get_branch, branch={目标分支})
+- 调用 `mcp_gitlab_browse_refs` (action=get_branch, project_id={project_id}, branch={目标分支})
+- **必需参数**：
+  - `action`: "get_branch"
+  - `project_id`: 项目 ID 或 URL 编码路径（如 "zhangkr/ai-test"）
+  - `branch`: 分支名称
 - 如果返回 404 或分支不存在：**立即停止执行**，输出：
   ```
   ❌ 目标分支不存在：{目标分支}
@@ -65,11 +69,12 @@ version: 1.0.0
 ### 1. MR 状态检查逻辑
 
 创建 MR 后执行：
+- **查询 MR 状态**：使用【查询 MR 工具】
 - 检查 `merge_status` 字段
 - 如果为 `cannot_be_merged`：
   1. **检查是否为无文件变更的情况**：比较 `diff_refs.base_sha` 和 `diff_refs.head_sha`
      - 如果两者相同（无实际文件变更）：
-       - 自动关闭 MR：`mcp_gitlab_manage_merge_request` (action=update, state_event=close)
+       - 执行【关闭 MR 逻辑】
        - 输出提示信息：
          ```
          ℹ️ MR 无文件变更（已合并过），自动关闭
@@ -93,8 +98,7 @@ version: 1.0.0
 
 ### 3. MR 合并逻辑
 
-执行 `mcp_gitlab_manage_merge_request` (action=merge)：
-- `merge_when_pipeline_succeeds: true`
+执行【合并 MR 工具】
 - 如果失败（如 405 错误）：**立即停止执行**，输出：
   ```
   ❌ MR 合并失败：{error_message}
@@ -102,40 +106,38 @@ version: 1.0.0
   请检查 MR 状态后手动处理
   ```
 
-## 执行流程
-
-### 前置检查: GitLab MCP 可用性验证
+### 4. 关闭 MR 逻辑
 
-在执行任何步骤前，必须先完成以下验证，**验证通过后才能继续，否则立即停止**：
+执行 `mcp_gitlab_manage_merge_request` (action=update, project_id={project_id}, merge_request_iid={iid}, source_branch={source_branch}, target_branch={target_branch}, state_event=close)
+- **必需参数**：
+  - `action`: "update"
+  - `project_id`: 项目 ID 或 URL 编码路径
+  - `merge_request_iid`: MR 的内部 ID
+  - `source_branch`: 源分支名称
+  - `target_branch`: 目标分支名称
+  - `state_event`: "close"
 
-1. 调用只读工具 `mcp_gitlab_browse_projects`（action=list, per_page=1）
-2. **判断结果**：
-   - 如果返回 `tool not found` 或 `not found MCPHost` 或 `50001` 错误码：**立即停止，禁止执行后续任何步骤**，输出：
-     ```
-     ❌ GitLab MCP 不可用，无法执行自动化 CI 流程
-     请在 MCP 配置中启用 GitLab MCP 后重试：
-     编辑器设置 → MCP → 启用 GitLab
-     ```
-   - 如果返回其他任何结果（含 404、401、数据等）：视为 MCP 可用，继续执行
+## 执行流程
 
 ### 步骤 1: 获取分支信息
 
 > **⚠️ 配置读取优先级**：按以下顺序读取配置，找到即停止：
 > 1. 项目根目录的 `config.yaml`
-> 2. 本 Skill 同级目录的 `template.yaml`
+> 2. 默认模版配置（Skill 目录下的 `template.yaml`）
 >
 > **必须每次重新读取**：禁止使用上下文缓存，每次执行 `/ci` 时都要重新读取配置。
 
 **配置读取逻辑**：
-1. 首先尝试读取项目根目录的 `config.yaml`
-2. 若 `config.yaml` 不存在或读取失败，则读取本 Skill 目录下的 `template.yaml`
+1. 首先尝试读取项目根目录的 `config.yaml`（使用 `read_file` 工具）
+2. 若 `config.yaml` 不存在或读取失败，则读取 Skill 目录下的默认配置 `template.yaml`
+   - 使用 `read_file` 工具读取 Skill 目录下的 `template.yaml` 文件
 3. 合并配置：以读取到的配置为基础，缺失的值使用 `template.yaml` 中的默认值补充
 
 1. **解析 SOURCE_BRANCH（源分支）和项目路径**：
    - 若用户传入了 `branch:分支名`，直接使用该分支作为 SOURCE_BRANCH
    - 若 `config.yaml` 中配置了 `projects.url`，从 URL 中解析项目路径
    - **若以上两者都未满足**，合并执行以下命令（一次终端调用获取全部信息）：
-     执行 `git branch --show-current && git remote get-url origin`，解析项目路径（如 zhangkr/ai-test）
+     执行 `git branch --show-current && git remote get-url origin`，解析项目路径
      - 第一行输出作为 SOURCE_BRANCH
      - 第二行输出解析为项目路径
 
@@ -153,12 +155,13 @@ version: 1.0.0
 
 1. **执行【分支存在性检查逻辑】**（目标分支：{PERSONAL_BRANCH}）
 
-2. **创建 MR**：`mcp_gitlab_manage_merge_request` (action=create)
+2. **创建 MR**：执行【创建 MR 工具】
    - source_branch: {SOURCE_BRANCH}
    - target_branch: {PERSONAL_BRANCH}
-   - title: `{mr_title_template}`（模板变量：{source_branch}, {target_branch}）
+   - 记录返回的 MR IID（`iid` 字段），用于后续查询
 
-3. **执行【MR 状态检查逻辑】**
+3. **执行【MR 状态检查】**
+   - 使用步骤 2 中获取的 MR IID 查询状态
 
 4. **执行【Review 检查逻辑】**（如果启用 Review 模式）
 
@@ -172,12 +175,13 @@ version: 1.0.0
 
 1. **执行【分支存在性检查逻辑】**（目标分支：{TARGET_BRANCH}）
 
-2. **创建 MR**：`mcp_gitlab_manage_merge_request` (action=create)
-   - source_branch: 根据上述规则确定
+2. **创建 MR**：执行【创建 MR 工具】
+   - source_branch: 根据规则确定（{PERSONAL_BRANCH} 或 {SOURCE_BRANCH}）
    - target_branch: {TARGET_BRANCH}
-   - title: `{mr_title_template}`（模板变量：{source_branch}, {target_branch}）
+   - 记录返回的 MR IID（`iid` 字段），用于后续查询
 
 3. **执行【MR 状态检查逻辑】**
+   - 使用步骤 2 中获取的 MR IID 查询状态
 
 4. **执行【Review 检查逻辑】**（如果启用 Review 模式）
 
@@ -227,8 +231,13 @@ version: 1.0.0
 2. **按照 CD skill 的规范执行部署流程**：
    - 执行 Jenkins MCP 可用性验证
    - 读取 `config.yaml` 中的 Jenkins 配置
-   - 使用 `mcp_jenkins_build_item` 触发构建
+   - 使用 `mcp_{jenkins_name}_build_item` 触发构建（如 `mcp_jenkins_build_item` 或 `mcp_jenkins_prod_build_item`）
    - **⚠️ 关键：`build_type` 必须为 `buildWithParameters`**
+   - **必需参数**：
+     - `fullname`: Jenkins Job 全名
+     - `build_type`: "buildWithParameters"
+     - `params`: 构建参数对象（如 `{BUILD_NAME: "build:dev:api"}`）
+   - **响应说明**：返回队列 ID（如 107941）
 
 3. **多环境部署**：按环境顺序逐个触发，记录每个环境的队列 ID
 
@@ -332,3 +341,118 @@ version: 1.0.0
 # 方式2：一体化执行
 /ci dev 发布      # 合并 + 部署一步完成
 ```
+
+---
+
+## 附录：工具参数参考
+
+### 公共工具定义
+
+以下工具在多个步骤中被复用，统一在此定义：
+
+#### 【查询 MR 工具】
+`mcp_gitlab_browse_merge_requests` - 查询 MR 状态
+- **必需参数**：
+  - `action`: "get"
+  - `project_id`: 项目 ID 或 URL 编码路径
+  - `merge_request_iid`: MR 内部 ID
+  - `per_page`: 每页数量（如 20）
+- **关键响应字段**：
+  - `merge_status`: 合并状态（"can_be_merged"）
+  - `state`: MR 状态（"opened"/"merged"/"closed"）
+  - `diff_refs.base_sha`: 基础提交 SHA
+  - `diff_refs.head_sha`: 头部提交 SHA
+  - `web_url`: MR 页面链接
+
+#### 【创建 MR 工具】
+`mcp_gitlab_manage_merge_request` - 创建新的合并请求
+- **必需参数**：
+  - `action`: "create"
+  - `project_id`: 项目 ID 或 URL 编码路径
+  - `source_branch`: 源分支名称
+  - `target_branch`: 目标分支名称
+  - `title`: MR 标题（支持模板变量）
+  - `description`: MR 描述（可选）
+- **关键响应字段**：
+  - `iid`: MR 内部 ID（必需记录）
+  - `web_url`: MR 页面链接
+  - `merge_status`: 合并状态
+
+#### 【合并 MR 工具】
+`mcp_gitlab_manage_merge_request` - 合并 MR
+- **必需参数**：
+  - `action`: "merge"
+  - `project_id`: 项目 ID 或 URL 编码路径
+  - `merge_request_iid`: MR 内部 ID
+  - `source_branch`: 源分支名称
+  - `target_branch`: 目标分支名称
+  - `merge_when_pipeline_succeeds`: true
+
+---
+
+### GitLab 工具详情
+
+#### 1. mcp_gitlab_browse_refs
+查询分支信息。
+
+**参数**：
+| 参数名 | 类型 | 必需 | 说明 |
+|--------|------|------|------|
+| `action` | string | ✅ | 固定值 "get_branch" |
+| `project_id` | string | ✅ | 项目 ID 或 URL 编码路径（如 "zhangkr/ai-test"） |
+| `branch` | string | ✅ | 分支名称 |
+
+**响应字段**：
+| 字段名 | 说明 |
+|--------|------|
+| `name` | 分支名称 |
+| `commit.id` | 最新提交 SHA |
+| `commit.title` | 最新提交标题 |
+| `merged` | 是否已合并 |
+| `protected` | 是否受保护 |
+
+#### 2. mcp_gitlab_browse_merge_requests
+查询 MR 信息。详见【查询 MR 工具】定义。
+
+**额外说明**：
+- `action=list` 时不需要 `merge_request_iid`
+- 支持分页参数：`page`, `per_page`
+
+#### 3. mcp_gitlab_manage_merge_request
+管理 MR（创建、更新、合并）。详见【创建 MR 工具】、【合并 MR 工具】、【关闭 MR 逻辑】定义。
+
+**update 专属参数**（关闭/重新打开 MR）：
+| 参数名 | 类型 | 必需 | 说明 |
+|--------|------|------|------|
+| `merge_request_iid` | number | ✅ | MR 内部 ID |
+| `source_branch` | string | ✅ | 源分支名称 |
+| `target_branch` | string | ✅ | 目标分支名称 |
+| `state_event` | string | ✅ | "close" 或 "reopen" |
+
+### Jenkins 工具
+
+#### mcp_{jenkins_name}_build_item
+触发 Jenkins 构建。
+
+**参数**：
+| 参数名 | 类型 | 必需 | 说明 |
+|--------|------|------|------|
+| `fullname` | string | ✅ | Jenkins Job 全名 |
+| `build_type` | string | ✅ | 固定值 "buildWithParameters" |
+| `params` | object | ✅ | 构建参数对象（如 `{BUILD_NAME: "build:dev:api"}`） |
+
+**响应**：
+- 成功：返回队列 ID（number，如 107941）
+- 失败：返回错误信息
+
+#### mcp_{jenkins_name}_get_all_items
+获取所有 Jenkins Jobs（用于可用性验证）。
+
+**参数**：
+| 参数名 | 类型 | 必需 | 说明 |
+|--------|------|------|------|
+| `random_string` | string | ✅ | 任意字符串（如 "check"） |
+
+**响应**：
+- 成功：返回 Job 列表数组
+- 失败：返回错误信息

package/dist/skills/ci/template.yaml

@@ -24,6 +24,19 @@ templates:
     - 目标分支: {target_branch}
     - 触发环境: {env}
     - 触发时间: {timestamp}
+jenkins:
+  is_current_branch: false
+  '广告主开发':
+    fullname: "dev-platforms-advertiser-140.227"
+    url: "http://10.169.140.235:30866/view/双统前台/job/dev-platforms-advertiser-140.227/"
+  '广告主测试':
+    fullname: "test-platforms-advertiser-140.227"
+    url: "http://10.169.140.235:30866/view/双统前台/job/test-platforms-advertiser-140.227/"
+jenkins-prod:
+  is_current_branch: false
+  '广告主准生产':
+    fullname: "uat-gtqt-platforms-advertiser-150.27"
+    url: "http://10.168.171.71:28080/view/uat-双统前台/job/uat-platforms-advertiser-150.27/"
 
 defaults:
   env: "dev"           # 默认环境

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postar-pipe-mcp",
-  "version": "0.0.2",
+  "version": "1.0.0",
   "description": "Unified CI/CD MCP Server - orchestrates GitLab and Jenkins MCPs with dynamic skills",
   "type": "module",
   "main": "dist/index.js",