@guru-ai-product/ai-product-kit 0.2.251112184032 → 0.2.251113155253

package/mcp/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../v4/mini/index.cjs"), exports);

package/mcp/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.cjs";

package/mcp/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/mcp/node_modules/zod/v4-mini/index.js

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/mcp/package-lock.json

@@ -0,0 +1,155 @@
+{
+  "name": "ai-product-kit-mcp",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "ai-product-kit-mcp",
+      "version": "1.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "@modelcontextprotocol/sdk": "^0.5.0"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-0.5.0.tgz",
+      "integrity": "sha512-RXgulUX6ewvxjAG0kOpLMEdXXWkzWgaoCGaA2CwNW7cQCIphjpJhjpHSiaPdVCnisjRF/0Cm9KWHUuIoeiAblQ==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.0.tgz",
+      "integrity": "sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.1.tgz",
+      "integrity": "sha512-9G8cA+tuMS75+6G/TzW8OtLzmBDMo8p1JRxN5AZ+LAp8uxGA8V8GZm4GQ4/N5QNQEnLmg6SS7wyuSmbKepiKqA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.7.0",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

package/mcp/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "ai-product-kit-mcp",
+  "version": "1.0.0",
+  "description": "AI Product Kit MCP Server - Node.js version",
+  "type": "module",
+  "main": "src/server.js",
+  "scripts": {
+    "start": "node src/server.js",
+    "test": "node src/test_server.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0"
+  },
+  "keywords": ["mcp", "ai-product-kit"],
+  "author": "",
+  "license": "MIT"
+}

package/mcp/requirements.txt

@@ -0,0 +1 @@
+mcp[cli] 

package/mcp/src/server.js

@@ -0,0 +1,208 @@
+/**
+ * AI Product Kit MCP Server - Core (Generated)
+ * DO NOT EDIT DIRECTLY - Regenerate via: node tools/build_package update-mcp
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import {
+  normalizeInput,
+  rewriteAndCacheMarkdown,
+  PROJECT_ROOT,
+} from './server_core.js';
+import { join } from 'path';
+
+// Product Kit Skills 映射 - 只包含 skills 下一级目录的主 skill
+// 每个键对应一个主 skill 目录，值是该 skill 的 SKILL.md 文件路径
+const PRODUCT_KIT_SKILLS = {
+  "aipk_design": join(PROJECT_ROOT, "skills/aipk_design/SKILL.md"),
+  "aipk_development": join(PROJECT_ROOT, "skills/aipk_development/SKILL.md"),
+  "aipk_init_project": join(PROJECT_ROOT, "skills/aipk_init_project/SKILL.md"),
+  "aipk_operations": join(PROJECT_ROOT, "skills/aipk_operations/SKILL.md"),
+  "aipk_requirements": join(PROJECT_ROOT, "skills/aipk_requirements/SKILL.md"),
+  "aipk_skill_generate": join(PROJECT_ROOT, "skills/aipk_skill_generate/SKILL.md"),
+  "aipk_tool_prompts": join(PROJECT_ROOT, "skills/aipk_tool_prompts/SKILL.md"),};
+
+// Skill 描述映射
+const SKILL_DESCRIPTIONS = {
+  "aipk_design": "Central hub for automation-ready design workflows, describing how agents split composite boards, prep visual assets, sync requirement docs, and discover the right sub-skill before handling new mocks.",
+  "aipk_development": "Development phase index pointing to the single authoritative implementation plan template.",
+  "aipk_init_project": "Initialize the project Agents playbook, sync the skills inventory into AGENTS.md/templates, and verify the workspace includes a complete AGENTS.md file.",
+  "aipk_operations": "Canonical entry point for every post-release operating guide; maps scenarios to the available Skills and explains how to invoke them.",
+  "aipk_requirements": "Central repository for requirement discovery, documentation, review, and change management assets.",
+  "aipk_skill_generate": "Standards and methods for creating Agent Skills that extend Claude's capabilities. Use when creating or updating Skills, rules, or documentation that should follow Skill structure.",
+  "aipk_tool_prompts": "Catalog of reusable prompts for AI tooling workflows, including their usage guidance and file locations.",};
+
+const server = new Server(
+  {
+    name: 'AI-Product-Kit-MCP',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+/**
+ * 生成支持的技能列表及其描述
+ */
+function getSupportedSkills() {
+  const supportedList = [];
+  for (const name of Object.keys(PRODUCT_KIT_SKILLS).sort()) {
+    const description = SKILL_DESCRIPTIONS[name] || 'No description available';
+    supportedList.push({
+      name,
+      description,
+    });
+  }
+  return supportedList;
+}
+
+/**
+ * 获取技能描述（从SKILL.md文件的第一行）
+ */
+async function extractSkillDescription(skillPath) {
+  let description = '';
+  try {
+    const fs = await import('fs');
+    const firstLine = fs.readFileSync(skillPath, 'utf-8')
+      .split('\n')[0]
+      .trim();
+    if (firstLine && !firstLine.startsWith('#')) {
+      description = firstLine.substring(0, 200); // 限制长度
+    }
+  } catch (error) {
+    // ignore
+  }
+  return description;
+}
+
+// 设置工具处理器
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  const skills = getSupportedSkills();
+
+  // 生成工具描述中的技能列表
+  let skillList = '';
+  for (const skill of skills) {
+    skillList += `    - ${skill.name}: ${skill.description}\n`;
+  }
+
+  return {
+    tools: [
+      {
+        name: 'product_kit_skill',
+        description: `获取 AI Product Kit 中指定技能的指南文档或模板。\n该工具提供对 AI Product Kit 所有技能的统一访问入口。\n参数说明：\n- skill_name (string): 要获取的技能名称。\n  具体说明如下：\n${skillList}\n返回信息：\n- skill_name: 技能名称\n- description: 技能描述\n- cache_path: 缓存文件绝对路径（用于后续读取内容）`,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            skill_name: {
+              type: 'string',
+              description: '需要获取的技能名称，具体可选值及其用途见上方说明',
+            },
+          },
+          required: ['skill_name'],
+        },
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  if (request.params.name === 'product_kit_skill') {
+    const skillName = request.params.arguments?.skill_name;
+
+    if (!skillName) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              error: 'Missing required parameter: skill_name',
+            }),
+          },
+        ],
+      };
+    }
+
+    const normalizedName = normalizeInput(skillName);
+
+    // 查找匹配的skill
+    let skillPath = null;
+    for (const [key, path] of Object.entries(PRODUCT_KIT_SKILLS)) {
+      if (normalizeInput(key) === normalizedName) {
+        skillPath = path;
+        break;
+      }
+    }
+
+    if (!skillPath) {
+      // 构建包含名称和描述的详细列表
+      const supportedList = getSupportedSkills();
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              error: `Unsupported skill name: ${skillName}`,
+              supported_skills: supportedList,
+            }, null, 2),
+          },
+        ],
+      };
+    }
+
+    const fs = await import('fs');
+    if (!fs.existsSync(skillPath)) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              error: `Skill file not found: ${skillPath}`,
+            }),
+          },
+        ],
+      };
+    }
+
+    const cachePath = rewriteAndCacheMarkdown(skillPath);
+    const description = await extractSkillDescription(skillPath);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(
+            {
+              skill_name: skillName,
+              description: description,
+              cache_path: cachePath,
+            },
+            null,
+            2
+          ),
+        },
+      ],
+    };
+  }
+
+  throw new Error(`Unknown tool: ${request.params.name}`);
+});
+
+// 主函数
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('AI Product Kit MCP Server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Fatal error in main():', error);
+  process.exit(1);
+});

package/mcp/src/server_core.js

@@ -0,0 +1,244 @@
+/**
+ * MCP Server Core - Node.js 版本
+ * 包含缓存逻辑、文件处理等固定方法
+ */
+
+import { createHash } from 'crypto';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, statSync } from 'fs';
+import { join, dirname, basename, resolve, normalize } from 'path';
+import { fileURLToPath } from 'url';
+
+// 获取项目根目录（mcp 目录的上一级）
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export const PROJECT_ROOT = resolve(__dirname, '../..');
+export const CACHE_DIR = join(__dirname, '../.doc_cache');
+export const CACHE_MAPPING_FILE = join(CACHE_DIR, 'cache_mapping.json');
+
+// 确保缓存目录存在
+if (!existsSync(CACHE_DIR)) {
+  mkdirSync(CACHE_DIR, { recursive: true });
+}
+
+/**
+ * 输入预处理：去除前后空格，全角转半角，英文小写
+ * @param {string} s - 输入字符串
+ * @returns {string} - 处理后的字符串
+ */
+export function normalizeInput(s) {
+  if (!s) return '';
+  // 去除前后空格
+  s = s.trim();
+  // 全角转半角（简化版）
+  s = s.replace(/[Ａ-Ｚａ-ｚ０-９]/g, (c) => String.fromCharCode(c.charCodeAt(0) - 0xfee0));
+  // 英文小写
+  s = s.toLowerCase();
+  return s;
+}
+
+/**
+ * 生成缓存文件路径
+ * @param {string} srcPath - 源文件路径
+ * @returns {string} - 缓存文件路径
+ */
+export function getCacheFilePath(srcPath) {
+  const absPath = resolve(srcPath);
+  const filename = basename(absPath);
+  const mtime = existsSync(absPath) ? statSync(absPath).mtime.getTime().toString() : '0';
+  const hashInput = `${absPath}:${mtime}`;
+  const pathHash = createHash('md5').update(hashInput).digest('hex').substring(0, 16);
+  const cacheFilename = `${pathHash}_${filename}`;
+  return resolve(join(CACHE_DIR, cacheFilename));
+}
+
+/**
+ * 获取源文件及其所有引用文件的最大修改时间
+ * 用于判断缓存是否需要更新
+ * @param {string} srcPath - 源文件路径
+ * @param {Set<string>} processed - 已处理的文件集合（防止循环引用）
+ * @returns {number} - 最大修改时间
+ */
+export function getReferencedFilesMtime(srcPath, processed = new Set()) {
+  const absSrcPath = resolve(srcPath);
+
+  if (processed.has(absSrcPath)) {
+    return 0; // 循环引用，返回0避免影响判断
+  }
+  processed.add(absSrcPath);
+
+  // 获取当前文件的修改时间
+  let maxMtime = existsSync(absSrcPath) ? statSync(absSrcPath).mtime.getTime() : 0;
+
+  let content;
+  try {
+    content = readFileSync(absSrcPath, 'utf-8');
+  } catch (error) {
+    return maxMtime;
+  }
+
+  // 查找所有本地md文件引用 [text](path.md)
+  const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+  let match;
+
+  while ((match = linkRegex.exec(content)) !== null) {
+    const link = match[2];
+    // 只处理本地md文件
+    if (!link.startsWith('http') && !link.startsWith('#') && link.endsWith('.md')) {
+      const targetPath = normalize(join(dirname(absSrcPath), link));
+      if (existsSync(targetPath)) {
+        // 递归获取引用文件的修改时间
+        const refMtime = getReferencedFilesMtime(targetPath, new Set(processed));
+        maxMtime = Math.max(maxMtime, refMtime);
+      }
+    }
+  }
+
+  return maxMtime;
+}
+
+/**
+ * 加载缓存映射文件
+ * @returns {Object} - 缓存映射对象
+ */
+export function loadCacheMapping() {
+  if (existsSync(CACHE_MAPPING_FILE)) {
+    try {
+      const content = readFileSync(CACHE_MAPPING_FILE, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * 保存缓存映射文件
+ * @param {Object} mapping - 缓存映射对象
+ */
+export function saveCacheMapping(mapping) {
+  writeFileSync(CACHE_MAPPING_FILE, JSON.stringify(mapping, null, 2), 'utf-8');
+}
+
+/**
+ * 检查缓存文件内容中的引用是否仍然有效
+ * @param {string} cachePath - 缓存文件路径
+ * @returns {boolean} - 是否有效
+ */
+export function isCacheContentValid(cachePath) {
+  let cacheContent;
+  try {
+    cacheContent = readFileSync(cachePath, 'utf-8');
+  } catch (error) {
+    return false;
+  }
+
+  const cacheMtime = statSync(cachePath).mtime.getTime();
+  const cacheMapping = loadCacheMapping();
+
+  // 查找缓存内容中的所有缓存文件路径
+  const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+  let match;
+
+  while ((match = linkRegex.exec(cacheContent)) !== null) {
+    const link = match[2];
+    // 检查是否是缓存文件路径（包含CACHE_DIR的绝对路径）
+    if (link.includes(CACHE_DIR) && link.endsWith('.md')) {
+      if (!existsSync(link)) {
+        return false; // 引用的缓存文件不存在，缓存无效
+      }
+
+      // 从映射文件中获取原始文件路径
+      const originalFile = cacheMapping[link];
+      if (!originalFile) {
+        return false; // 映射文件中没有找到原始文件路径
+      }
+      if (existsSync(originalFile)) {
+        try {
+          const originalMtime = statSync(originalFile).mtime.getTime();
+          if (originalMtime > cacheMtime) {
+            return false; // 原始文件比当前缓存文件新，缓存无效
+          }
+        } catch (error) {
+          return false;
+        }
+      } else {
+        return false; // 原始文件不存在，缓存无效
+      }
+    }
+  }
+
+  return true;
+}
+
+/**
+ * 递归改写Markdown文件中的本地链接，并缓存改写结果
+ * @param {string} srcPath - 源文件路径
+ * @param {Set<string>} processed - 已处理的文件集合（防止循环引用）
+ * @returns {string} - 缓存文件绝对路径
+ */
+export function rewriteAndCacheMarkdown(srcPath, processed = new Set()) {
+  const absSrcPath = resolve(srcPath);
+
+  if (processed.has(absSrcPath)) {
+    return getCacheFilePath(absSrcPath); // 防止循环引用死循环，直接返回缓存路径
+  }
+  processed.add(absSrcPath);
+
+  const cachePath = getCacheFilePath(absSrcPath);
+
+  // 检查缓存是否可用 - 考虑所有引用文件的修改时间
+  if (existsSync(cachePath)) {
+    const maxSrcMtime = getReferencedFilesMtime(absSrcPath, new Set());
+    const cacheMtime = statSync(cachePath).mtime.getTime();
+    if (cacheMtime >= maxSrcMtime && isCacheContentValid(cachePath)) {
+      return cachePath;
+    }
+  }
+
+  // 读取并改写内容
+  let content;
+  try {
+    content = readFileSync(absSrcPath, 'utf-8');
+  } catch (error) {
+    throw new Error(`源文件不存在: ${absSrcPath}`);
+  }
+
+  // 匹配Markdown本地链接：[text](path.md)
+  const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+  let newContent = content;
+  let match;
+
+  while ((match = linkRegex.exec(content)) !== null) {
+    const text = match[1];
+    const link = match[2];
+
+    // 只处理本地md文件，忽略http/https/锚点/图片等
+    if (link.startsWith('http') || link.startsWith('#') || !link.endsWith('.md')) {
+      continue;
+    }
+
+    // 计算被引用文件的绝对路径
+    const targetPath = normalize(join(dirname(absSrcPath), link));
+
+    if (existsSync(targetPath)) {
+      // 目标文件存在，递归处理并替换为缓存路径
+      const targetCache = rewriteAndCacheMarkdown(targetPath, new Set(processed));
+      newContent = newContent.replace(
+        `[${text}](${link})`,
+        `[${text}](${targetCache})`
+      );
+    }
+  }
+
+  // 写入缓存
+  writeFileSync(cachePath, newContent, 'utf-8');
+
+  // 更新缓存映射文件
+  const cacheMapping = loadCacheMapping();
+  cacheMapping[cachePath] = absSrcPath;
+  saveCacheMapping(cacheMapping);
+
+  return cachePath;
+}