mcp-feature-doc-generator 1.0.0 → 1.0.2

package/dist/analysis/feature-context.d.ts

@@ -0,0 +1,15 @@
+export type FeatureDocContextBundle = {
+    featurePath: string;
+    featureDir: string;
+    outputPath: string;
+    promptText: string;
+    featureFiles: string[];
+    dependencyFiles: string[];
+    componentNames: string[];
+    apiImports: string[];
+    dictImports: string[];
+    permissionTokens: string[];
+    warnings: string[];
+    renderedText: string;
+};
+export declare function collectFeatureDocContext(rawFeaturePath: string, promptText: string, workspaceRoot?: string): FeatureDocContextBundle;

package/dist/analysis/feature-context.js

@@ -0,0 +1,491 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, extname, relative, resolve, sep } from "node:path";
+const SOURCE_EXTENSIONS = [".vue", ".ts", ".js"];
+const PRIMARY_FILE_ORDER = ["index.vue", "form.vue", "options.ts", "options.js"];
+const EXCLUDED_TOP_LEVEL_DIRS = new Set(["error", "login", "demo", "i18n", "components"]);
+const FORCED_IGNORE_NAMES = new Set([
+    "microme-operator",
+    "upload-file",
+    "process",
+    "customquery",
+    "tablecolumndrawer",
+    "exportexcel",
+    "circulationform",
+]);
+const MAX_FEATURE_FILES = 10;
+const MAX_DEPENDENCY_FILES = 4;
+const MAX_SNIPPET_LINES = 220;
+const MAX_SNIPPET_MATCHES = 18;
+const DYNAMIC_IMPORT_REGEX = /import\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g;
+const STATIC_IMPORT_REGEX = /from\s+["'`]([^"'`]+)["'`]/g;
+const COMPONENT_NAME_REGEXES = [
+    /<script[^>]*\bname=["'`]([^"'`]+)["'`][^>]*>/g,
+    /defineOptions\s*\(\s*{[\s\S]*?\bname\s*:\s*["'`]([^"'`]+)["'`]/g,
+];
+const PERMISSION_ATTRIBUTE_REGEXES = [
+    /(?:v-auth|v-hasPermi)\s*=\s*"([^"]*)"/g,
+    /(?:v-auth|v-hasPermi)\s*=\s*'([^']*)'/g,
+];
+const PERMISSION_TOKEN_REGEX = /[A-Za-z][A-Za-z0-9:-]*(?:_[A-Za-z0-9:-]+)+/g;
+const SNIPPET_HINT_REGEX = /defineAsyncComponent|from\s+['"`]\/@\/api|from\s+['"`]\.\/|from\s+['"`]\.\.\/|defineProps|defineEmits|watch\s*\(|computed\s*\(|submit|save|validate|fetch|addObj|putObj|delObj|getObj|openDialog|processDefKey|useRoute|useI18n|<el-table|<el-form|<template|@click|@change|@submit/i;
+export function collectFeatureDocContext(rawFeaturePath, promptText, workspaceRoot = detectWorkspaceRoot(process.cwd())) {
+    const featurePath = normalizeFeaturePath(rawFeaturePath);
+    const topLevelDir = featurePath.split("/")[0];
+    if (EXCLUDED_TOP_LEVEL_DIRS.has(topLevelDir)) {
+        throw new Error(`指定路径位于非业务目录：src/views/${featurePath}`);
+    }
+    const featureDir = resolve(workspaceRoot, "src", "views", ...featurePath.split("/"));
+    if (!existsSync(featureDir) || !statSync(featureDir).isDirectory()) {
+        throw new Error(`功能目录不存在：src/views/${featurePath}`);
+    }
+    const allFeatureFiles = walkSourceFiles(featureDir);
+    if (allFeatureFiles.length === 0) {
+        throw new Error(`功能目录下未找到可分析的 vue/ts/js 文件：src/views/${featurePath}`);
+    }
+    const warnings = [];
+    const hasPrimaryFile = allFeatureFiles.some((filePath) => PRIMARY_FILE_ORDER.includes(relative(featureDir, filePath).split(sep).join("/")));
+    if (!hasPrimaryFile) {
+        warnings.push("未检测到 index.vue、form.vue 或 options.ts，已退化为分析目录下的源码文件。");
+    }
+    const featureFiles = sortSourceFiles(allFeatureFiles, featureDir).slice(0, MAX_FEATURE_FILES);
+    const dependencyFiles = collectDependencyFiles(featureFiles, featureDir, workspaceRoot).slice(0, MAX_DEPENDENCY_FILES);
+    const insights = [
+        ...featureFiles.map((filePath) => analyzeFile(filePath, "feature", workspaceRoot, featureDir)),
+        ...dependencyFiles.map((filePath) => analyzeFile(filePath, "dependency", workspaceRoot, featureDir)),
+    ];
+    const componentNames = unique(insights.flatMap((item) => item.componentNames));
+    const apiImports = unique(insights.flatMap((item) => item.apiImports));
+    const dictImports = unique(insights.flatMap((item) => item.dictImports));
+    const permissionTokens = unique(insights.flatMap((item) => item.permissionTokens));
+    const renderedText = renderContextBundle({
+        featurePath,
+        outputPath: `开发规范/views/${featurePath}-README.md`,
+        promptText,
+        insights,
+        componentNames,
+        apiImports,
+        dictImports,
+        permissionTokens,
+        warnings,
+    });
+    return {
+        featurePath,
+        featureDir,
+        outputPath: `开发规范/views/${featurePath}-README.md`,
+        promptText,
+        featureFiles: featureFiles.map((filePath) => toRepoPath(filePath, workspaceRoot)),
+        dependencyFiles: dependencyFiles.map((filePath) => toRepoPath(filePath, workspaceRoot)),
+        componentNames,
+        apiImports,
+        dictImports,
+        permissionTokens,
+        warnings,
+        renderedText,
+    };
+}
+function detectWorkspaceRoot(startDir) {
+    let currentDir = resolve(startDir);
+    while (true) {
+        const viewsDir = resolve(currentDir, "src", "views");
+        if (existsSync(viewsDir) && statSync(viewsDir).isDirectory()) {
+            return currentDir;
+        }
+        const parentDir = resolve(currentDir, "..");
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw new Error("未找到项目根目录，请确保当前工作目录或其父目录下存在 src/views。");
+}
+function normalizeFeaturePath(rawFeaturePath) {
+    const featurePath = rawFeaturePath.trim().replace(/\\/g, "/").replace(/^src\/views\//, "").replace(/^\/+|\/+$/g, "");
+    if (!featurePath) {
+        throw new Error("featurePath 不能为空。");
+    }
+    const segments = featurePath.split("/");
+    if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
+        throw new Error(`featurePath 非法：${rawFeaturePath}`);
+    }
+    return segments.join("/");
+}
+function walkSourceFiles(rootDir) {
+    const results = [];
+    for (const entry of readdirSync(rootDir, { withFileTypes: true })) {
+        const fullPath = resolve(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkSourceFiles(fullPath));
+            continue;
+        }
+        if (SOURCE_EXTENSIONS.includes(extname(entry.name))) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+function sortSourceFiles(filePaths, baseDir) {
+    return [...filePaths].sort((left, right) => {
+        const leftRelative = relative(baseDir, left).split(sep).join("/");
+        const rightRelative = relative(baseDir, right).split(sep).join("/");
+        const leftPriority = filePriority(leftRelative);
+        const rightPriority = filePriority(rightRelative);
+        if (leftPriority !== rightPriority) {
+            return leftPriority - rightPriority;
+        }
+        return leftRelative.localeCompare(rightRelative);
+    });
+}
+function filePriority(relativePath) {
+    const exactIndex = PRIMARY_FILE_ORDER.indexOf(relativePath);
+    if (exactIndex >= 0) {
+        return exactIndex;
+    }
+    const fileName = relativePath.split("/").pop() ?? relativePath;
+    const fallbackIndex = PRIMARY_FILE_ORDER.indexOf(fileName);
+    if (fallbackIndex >= 0) {
+        return PRIMARY_FILE_ORDER.length + fallbackIndex;
+    }
+    if (relativePath.endsWith(".vue")) {
+        return 20;
+    }
+    if (relativePath.endsWith(".ts")) {
+        return 30;
+    }
+    return 40;
+}
+function collectDependencyFiles(featureFiles, featureDir, workspaceRoot) {
+    const dependencies = new Set();
+    for (const filePath of featureFiles) {
+        const source = readFileSync(filePath, "utf-8");
+        for (const specifier of extractImportSpecifiers(source)) {
+            const resolvedPath = resolveViewImport(filePath, specifier, workspaceRoot);
+            if (!resolvedPath) {
+                continue;
+            }
+            if (isInsideDir(resolvedPath, featureDir)) {
+                continue;
+            }
+            if (isForcedIgnored(resolvedPath)) {
+                continue;
+            }
+            dependencies.add(resolvedPath);
+        }
+    }
+    return sortSourceFiles([...dependencies], resolve(workspaceRoot, "src", "views"));
+}
+function extractImportSpecifiers(source) {
+    const values = extractStaticImportStatements(source)
+        .map((statement) => parseImportStatement(statement)?.specifier)
+        .filter((value) => Boolean(value));
+    DYNAMIC_IMPORT_REGEX.lastIndex = 0;
+    let match = DYNAMIC_IMPORT_REGEX.exec(source);
+    while (match) {
+        values.push(match[1]);
+        match = DYNAMIC_IMPORT_REGEX.exec(source);
+    }
+    return unique(values);
+}
+function resolveViewImport(sourceFilePath, specifier, workspaceRoot) {
+    const normalizedSpecifier = specifier.trim();
+    let candidate;
+    if (normalizedSpecifier.startsWith("/@/views/")) {
+        candidate = resolve(workspaceRoot, "src", "views", normalizedSpecifier.slice("/@/views/".length));
+    }
+    else if (normalizedSpecifier.startsWith("@/views/")) {
+        candidate = resolve(workspaceRoot, "src", "views", normalizedSpecifier.slice("@/views/".length));
+    }
+    else if (normalizedSpecifier.startsWith("src/views/")) {
+        candidate = resolve(workspaceRoot, normalizedSpecifier);
+    }
+    else if (normalizedSpecifier.startsWith("./") || normalizedSpecifier.startsWith("../")) {
+        candidate = resolve(dirname(sourceFilePath), normalizedSpecifier);
+    }
+    if (!candidate) {
+        return undefined;
+    }
+    return resolveSourceCandidate(candidate);
+}
+function resolveSourceCandidate(candidate) {
+    if (existsSync(candidate)) {
+        const stats = statSync(candidate);
+        if (stats.isFile() && SOURCE_EXTENSIONS.includes(extname(candidate))) {
+            return candidate;
+        }
+        if (stats.isDirectory()) {
+            for (const fileName of PRIMARY_FILE_ORDER) {
+                const entry = resolve(candidate, fileName);
+                if (existsSync(entry) && statSync(entry).isFile()) {
+                    return entry;
+                }
+            }
+            const nestedFiles = walkSourceFiles(candidate);
+            if (nestedFiles.length > 0) {
+                return sortSourceFiles(nestedFiles, candidate)[0];
+            }
+        }
+    }
+    for (const extension of SOURCE_EXTENSIONS) {
+        const filePath = `${candidate}${extension}`;
+        if (existsSync(filePath) && statSync(filePath).isFile()) {
+            return filePath;
+        }
+    }
+    for (const fileName of PRIMARY_FILE_ORDER) {
+        const filePath = resolve(candidate, fileName);
+        if (existsSync(filePath) && statSync(filePath).isFile()) {
+            return filePath;
+        }
+    }
+    return undefined;
+}
+function analyzeFile(filePath, scope, workspaceRoot, featureDir) {
+    const source = readFileSync(filePath, "utf-8");
+    return {
+        repoPath: toRepoPath(filePath, workspaceRoot),
+        scope,
+        componentNames: extractComponentNames(source),
+        apiImports: extractApiImports(source),
+        dictImports: extractDictImports(source),
+        permissionTokens: extractPermissionTokens(source),
+        viewImports: extractImportSpecifiers(source)
+            .map((specifier) => resolveViewImport(filePath, specifier, workspaceRoot))
+            .filter((value) => Boolean(value))
+            .filter((resolvedPath) => !isInsideDir(resolvedPath, featureDir))
+            .filter((resolvedPath) => !isForcedIgnored(resolvedPath))
+            .map((resolvedPath) => toRepoPath(resolvedPath, workspaceRoot)),
+        snippet: buildSnippet(source),
+    };
+}
+function extractComponentNames(source) {
+    const values = [];
+    for (const regex of COMPONENT_NAME_REGEXES) {
+        regex.lastIndex = 0;
+        let match = regex.exec(source);
+        while (match) {
+            values.push(match[1]);
+            match = regex.exec(source);
+        }
+    }
+    return unique(values);
+}
+function extractApiImports(source) {
+    return unique(extractStaticImportStatements(source)
+        .map((statement) => parseImportStatement(statement))
+        .filter((parsed) => Boolean(parsed))
+        .filter((parsed) => parsed.specifier.startsWith("/@/api/"))
+        .map((parsed) => `${parsed.specifier.slice("/@/api/".length)} :: ${compactImportNames(parsed.clause)}`));
+}
+function extractDictImports(source) {
+    return unique(extractStaticImportStatements(source)
+        .map((statement) => parseImportStatement(statement))
+        .filter((parsed) => Boolean(parsed))
+        .filter((parsed) => parsed.specifier === "/@/enums/dict")
+        .map((parsed) => compactImportNames(parsed.clause)));
+}
+function extractPermissionTokens(source) {
+    const values = [];
+    for (const regex of PERMISSION_ATTRIBUTE_REGEXES) {
+        regex.lastIndex = 0;
+        let match = regex.exec(source);
+        while (match) {
+            const attributeValue = match[1];
+            const tokens = attributeValue.match(PERMISSION_TOKEN_REGEX);
+            if (tokens) {
+                values.push(...tokens);
+            }
+            match = regex.exec(source);
+        }
+    }
+    return unique(values);
+}
+function compactImportNames(rawImportClause) {
+    return rawImportClause
+        .replace(/\btype\b/g, "")
+        .replace(/\s+/g, " ")
+        .replace(/[{}]/g, "")
+        .trim();
+}
+function buildSnippet(source) {
+    const normalizedSource = source.replace(/\r\n/g, "\n");
+    const lines = normalizedSource.split("\n");
+    if (lines.length <= MAX_SNIPPET_LINES) {
+        return formatLineRange(lines, 0, lines.length - 1);
+    }
+    const ranges = [[0, Math.min(lines.length - 1, 119)]];
+    const interestingLines = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        if (SNIPPET_HINT_REGEX.test(lines[index])) {
+            interestingLines.push(index);
+            if (interestingLines.length >= MAX_SNIPPET_MATCHES) {
+                break;
+            }
+        }
+    }
+    for (const lineIndex of interestingLines) {
+        ranges.push([Math.max(0, lineIndex - 6), Math.min(lines.length - 1, lineIndex + 12)]);
+    }
+    const mergedRanges = mergeRanges(ranges);
+    const output = [];
+    let emittedLines = 0;
+    let previousEnd = -1;
+    for (const [start, end] of mergedRanges) {
+        if (emittedLines >= MAX_SNIPPET_LINES) {
+            break;
+        }
+        if (start > previousEnd + 1) {
+            output.push("...");
+        }
+        const availableLines = MAX_SNIPPET_LINES - emittedLines;
+        const cappedEnd = Math.min(end, start + availableLines - 1);
+        output.push(formatLineRange(lines, start, cappedEnd));
+        emittedLines += cappedEnd - start + 1;
+        previousEnd = cappedEnd;
+    }
+    if (previousEnd < lines.length - 1) {
+        output.push("...");
+    }
+    return output.join("\n");
+}
+function mergeRanges(ranges) {
+    const sortedRanges = [...ranges].sort((left, right) => left[0] - right[0]);
+    const merged = [];
+    for (const [start, end] of sortedRanges) {
+        const previous = merged[merged.length - 1];
+        if (!previous || start > previous[1] + 1) {
+            merged.push([start, end]);
+            continue;
+        }
+        previous[1] = Math.max(previous[1], end);
+    }
+    return merged;
+}
+function formatLineRange(lines, start, end) {
+    const output = [];
+    for (let index = start; index <= end; index += 1) {
+        output.push(`${String(index + 1).padStart(4, " ")} | ${lines[index]}`);
+    }
+    return output.join("\n");
+}
+function renderContextBundle(params) {
+    const { featurePath, outputPath, promptText, insights, componentNames, apiImports, dictImports, permissionTokens, warnings } = params;
+    const featureInsights = insights.filter((item) => item.scope === "feature");
+    const dependencyInsights = insights.filter((item) => item.scope === "dependency");
+    const blocks = [];
+    blocks.push("请直接基于下面的固定提示词与代码上下文继续完成任务，不要要求用户重复提供整段提示词。");
+    blocks.push("");
+    blocks.push("## 本次目标");
+    blocks.push(`- featurePath: \`src/views/${featurePath}\``);
+    blocks.push(`- 建议输出: \`${outputPath}\``);
+    blocks.push("");
+    blocks.push("## 固定提示词");
+    blocks.push("```text");
+    blocks.push(promptText);
+    blocks.push("```");
+    blocks.push("");
+    blocks.push("## 自动收集的上下文摘要");
+    blocks.push(`- 主功能源码文件: ${joinList(featureInsights.map((item) => `\`${item.repoPath}\``))}`);
+    blocks.push(`- 直接引用的业务文件: ${joinList(dependencyInsights.map((item) => `\`${item.repoPath}\``), "未检测到")}`);
+    blocks.push(`- 组件名称: ${joinList(componentNames.map((item) => `\`${item}\``), "未检测到")}`);
+    blocks.push(`- API 模块: ${joinList(apiImports.map((item) => `\`${item}\``), "未检测到")}`);
+    blocks.push(`- 字典引用: ${joinList(dictImports.map((item) => `\`${item}\``), "未检测到")}`);
+    blocks.push(`- 权限标识: ${joinList(permissionTokens.map((item) => `\`${item}\``), "未检测到")}`);
+    if (warnings.length > 0) {
+        blocks.push(`- 额外提示: ${joinList(warnings, "无")}`);
+    }
+    blocks.push("");
+    blocks.push("## 相关源码片段");
+    for (const insight of insights) {
+        blocks.push("");
+        blocks.push(`### ${insight.repoPath} [${insight.scope}]`);
+        if (insight.viewImports.length > 0) {
+            blocks.push(`- 直接引用的业务视图: ${joinList(insight.viewImports.map((item) => `\`${item}\``))}`);
+        }
+        if (insight.apiImports.length > 0) {
+            blocks.push(`- API 导入: ${joinList(insight.apiImports.map((item) => `\`${item}\``))}`);
+        }
+        if (insight.dictImports.length > 0) {
+            blocks.push(`- 字典导入: ${joinList(insight.dictImports.map((item) => `\`${item}\``))}`);
+        }
+        if (insight.permissionTokens.length > 0) {
+            blocks.push(`- 权限标识: ${joinList(insight.permissionTokens.map((item) => `\`${item}\``))}`);
+        }
+        blocks.push("```text");
+        blocks.push(insight.snippet);
+        blocks.push("```");
+    }
+    blocks.push("");
+    blocks.push("## 继续执行要求");
+    blocks.push("- 直接使用上面的固定提示词，不要改写提示词规则。");
+    blocks.push(`- 仅基于 \`src/views/${featurePath}\` 及已收集到的直接引用业务文件继续分析。`);
+    blocks.push("- 如果上下文不足，再以当前已识别的文件路径为线索做最小增量阅读，不要扩展到未引用功能。");
+    return blocks.join("\n");
+}
+function joinList(values, emptyText = "无") {
+    return values.length > 0 ? values.join("、") : emptyText;
+}
+function extractStaticImportStatements(source) {
+    const lines = source.replace(/\r\n/g, "\n").split("\n");
+    const statements = [];
+    let currentStatement = [];
+    let collecting = false;
+    for (const line of lines) {
+        const trimmedLine = stripInlineComment(line).trim();
+        if (!collecting) {
+            if (!trimmedLine.startsWith("import ")) {
+                continue;
+            }
+            collecting = true;
+            currentStatement = [trimmedLine];
+            if (trimmedLine.includes(" from ")) {
+                statements.push(currentStatement.join(" "));
+                currentStatement = [];
+                collecting = false;
+            }
+            continue;
+        }
+        currentStatement.push(trimmedLine);
+        if (trimmedLine.includes(" from ")) {
+            statements.push(currentStatement.join(" "));
+            currentStatement = [];
+            collecting = false;
+        }
+    }
+    return statements;
+}
+function parseImportStatement(statement) {
+    const normalizedStatement = statement.replace(/;$/, "");
+    const match = normalizedStatement.match(/^import\s+([\s\S]*?)\s+from\s+["'`]([^"'`]+)["'`]$/);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        clause: match[1],
+        specifier: match[2],
+    };
+}
+function stripInlineComment(line) {
+    const commentIndex = line.indexOf("//");
+    if (commentIndex < 0) {
+        return line;
+    }
+    const quoteCount = (line.slice(0, commentIndex).match(/["'`]/g) ?? []).length;
+    if (quoteCount % 2 !== 0) {
+        return line;
+    }
+    return line.slice(0, commentIndex);
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function toRepoPath(filePath, workspaceRoot) {
+    return relative(workspaceRoot, filePath).split(sep).join("/");
+}
+function isInsideDir(targetPath, dirPath) {
+    const relativePath = relative(dirPath, targetPath);
+    return relativePath === "" || (!relativePath.startsWith("..") && !relativePath.startsWith(`..${sep}`));
+}
+function isForcedIgnored(filePath) {
+    const fileName = filePath.split(/[\\/]/).pop() ?? "";
+    const normalizedName = fileName.replace(/\.(vue|ts|js)$/i, "").toLowerCase();
+    return FORCED_IGNORE_NAMES.has(normalizedName);
+}

package/dist/index.js

@@ -2,18 +2,31 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { PROMPT_NAME, PROMPT_DESCRIPTION, buildPromptMessages, } from "./prompts/generate-feature-doc.js";
+import { collectFeatureDocContext } from "./analysis/feature-context.js";
+import { PROMPT_DESCRIPTION, PROMPT_NAME, buildPromptMessages, } from "./prompts/generate-feature-doc.js";
 import { getTemplateContent } from "./resources/template.js";
+const SERVER_VERSION = "1.0.2";
+const FEATURE_PATH_DESCRIPTION = "功能路径，如 project/pmbasupplierevaluation 或 pm/ba/PmBaRentcontractSettle";
 const server = new McpServer({
     name: "feature-doc-generator",
-    version: "1.0.0",
+    version: SERVER_VERSION,
 });
-// 注册 prompt
-server.prompt(PROMPT_NAME, PROMPT_DESCRIPTION, { featurePath: z.string().describe("功能路径，如 project/pmbasupplierevaluation 或 pm/ba/PmBaRentcontractSettle") }, ({ featurePath }) => ({
+function getPromptText(featurePath) {
+    const [message] = buildPromptMessages(featurePath);
+    if (!message || typeof message.content !== "object" || message.content.type !== "text") {
+        throw new Error("Failed to build feature doc prompt text.");
+    }
+    return message.content.text;
+}
+server.prompt(PROMPT_NAME, PROMPT_DESCRIPTION, {
+    featurePath: z.string().describe(FEATURE_PATH_DESCRIPTION),
+}, ({ featurePath }) => ({
     messages: buildPromptMessages(featurePath),
 }));
-// 注册 resource：功能说明模板
-server.resource("doc-template", "template://feature-doc", { description: "功能说明文档模板（开发规范/功能说明模板.md）", mimeType: "text/markdown" }, () => ({
+server.resource("doc-template", "template://feature-doc", {
+    description: "功能说明文档模板（开发规范/功能说明模板.md）",
+    mimeType: "text/markdown",
+}, () => ({
     contents: [
         {
             uri: "template://feature-doc",
@@ -22,11 +35,39 @@ server.resource("doc-template", "template://feature-doc", { description: "功能
         },
     ],
 }));
+server.tool("generate_feature_doc", "返回固定提示词和自动收集的代码上下文，供 IDE 当前模型继续生成文档。", {
+    featurePath: z.string().describe(FEATURE_PATH_DESCRIPTION),
+}, async ({ featurePath }) => {
+    try {
+        const promptText = getPromptText(featurePath);
+        const contextBundle = collectFeatureDocContext(featurePath, promptText);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: contextBundle.renderedText,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "未知错误";
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `generate_feature_doc 执行失败：${message}`,
+                },
+            ],
+        };
+    }
+});
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }
-main().catch((err) => {
-    console.error("MCP server failed to start:", err);
+main().catch((error) => {
+    console.error("MCP server failed to start:", error);
     process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-feature-doc-generator",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "MCP server for generating Vue 3 feature documentation via prompt template",
   "type": "module",
   "main": "dist/index.js",