mta-mcp 2.2.0 → 2.3.0

package/dist/index.js

@@ -0,0 +1,4769 @@
+#!/usr/bin/env node
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/analyzeProject.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+
+// src/core/smartAgentMatcher.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import glob from "fast-glob";
+var SmartAgentMatcher = class {
+  constructor(logger3) {
+    this.logger = logger3;
+  }
+  /**
+   * 分析项目特征
+   */
+  async analyzeProject(workspaceFolder) {
+    this.log(`\u{1F50D} \u5F00\u59CB\u5206\u6790\u9879\u76EE: ${workspaceFolder.name}`);
+    const features = {
+      frameworks: [],
+      languages: [],
+      tools: [],
+      keywords: [],
+      projectType: "unknown"
+    };
+    const rootPath = workspaceFolder.uri.fsPath;
+    const pubspecPath = path2.join(rootPath, "pubspec.yaml");
+    if (fs.existsSync(pubspecPath)) {
+      const pubspecFeatures = this.analyzePubspecYaml(pubspecPath);
+      this.mergeFeatures(features, pubspecFeatures);
+      features.projectType = "flutter";
+      this.log(`\u2705 \u9879\u76EE\u5206\u6790\u5B8C\u6210: ${features.projectType}`);
+      return features;
+    }
+    const packageJsonPath = path2.join(rootPath, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageFeatures = this.analyzePackageJson(packageJsonPath);
+      this.mergeFeatures(features, packageFeatures);
+    }
+    const structureFeatures = await this.analyzeFileStructure(rootPath);
+    this.mergeFeatures(features, structureFeatures);
+    features.projectType = this.inferProjectType(features);
+    this.log(`\u2705 \u9879\u76EE\u5206\u6790\u5B8C\u6210: ${features.projectType}`);
+    return features;
+  }
+  /**
+   * 分析 package.json
+   */
+  analyzePackageJson(packageJsonPath) {
+    var _a, _b;
+    const features = {
+      frameworks: [],
+      languages: [],
+      tools: [],
+      keywords: []
+    };
+    try {
+      const content = fs.readFileSync(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(content);
+      const allDeps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      if (allDeps["vue"]) features.frameworks.push("Vue 3");
+      if (allDeps["react"]) features.frameworks.push("React");
+      if (allDeps["@angular/core"]) features.frameworks.push("Angular");
+      if (allDeps["next"]) features.frameworks.push("Next.js");
+      if (allDeps["nuxt"]) features.frameworks.push("Nuxt.js");
+      if (allDeps["svelte"]) features.frameworks.push("Svelte");
+      if (allDeps["solid-js"]) features.frameworks.push("Solid.js");
+      if (allDeps["preact"]) features.frameworks.push("Preact");
+      if (allDeps["remix"]) features.frameworks.push("Remix");
+      if (allDeps["astro"]) features.frameworks.push("Astro");
+      if (allDeps["express"]) features.frameworks.push("Express");
+      if (allDeps["koa"]) features.frameworks.push("Koa");
+      if (allDeps["fastify"]) features.frameworks.push("Fastify");
+      if (allDeps["nestjs"] || allDeps["@nestjs/core"]) features.frameworks.push("NestJS");
+      if (allDeps["egg"]) features.frameworks.push("Egg.js");
+      if (allDeps["midway"]) features.frameworks.push("Midway");
+      if (allDeps["hapi"]) features.frameworks.push("Hapi");
+      if (allDeps["meteor"]) features.frameworks.push("Meteor");
+      if (allDeps["blitz"]) features.frameworks.push("Blitz.js");
+      if (allDeps["vite"]) features.tools.push("Vite");
+      if (allDeps["webpack"]) features.tools.push("Webpack");
+      if (allDeps["rollup"]) features.tools.push("Rollup");
+      if (allDeps["parcel"]) features.tools.push("Parcel");
+      if (allDeps["esbuild"]) features.tools.push("ESBuild");
+      if (allDeps["turbopack"]) features.tools.push("Turbopack");
+      if (allDeps["element-plus"]) features.tools.push("Element Plus");
+      if (allDeps["ant-design-vue"]) features.tools.push("Ant Design Vue");
+      if (allDeps["antd"]) features.tools.push("Ant Design");
+      if (allDeps["@mui/material"]) features.tools.push("Material-UI");
+      if (allDeps["naive-ui"]) features.tools.push("Naive UI");
+      if (allDeps["vuetify"]) features.tools.push("Vuetify");
+      if (allDeps["quasar"]) features.tools.push("Quasar");
+      if (allDeps["primevue"]) features.tools.push("PrimeVue");
+      if (allDeps["chakra-ui"]) features.tools.push("Chakra UI");
+      if (allDeps["@headlessui/react"] || allDeps["@headlessui/vue"]) features.tools.push("Headless UI");
+      if (allDeps["daisyui"]) features.tools.push("DaisyUI");
+      if (allDeps["shadcn-ui"] || allDeps["@shadcn/ui"]) features.tools.push("Shadcn UI");
+      if (allDeps["tailwindcss"]) features.tools.push("Tailwind CSS");
+      if (allDeps["sass"] || allDeps["node-sass"]) features.tools.push("Sass");
+      if (allDeps["less"]) features.tools.push("Less");
+      if (allDeps["postcss"]) features.tools.push("PostCSS");
+      if (allDeps["styled-components"]) features.tools.push("Styled Components");
+      if (allDeps["emotion"]) features.tools.push("Emotion");
+      if (allDeps["unocss"]) features.tools.push("UnoCSS");
+      if (allDeps["@logicflow/core"]) features.tools.push("LogicFlow");
+      if (allDeps["echarts"]) features.tools.push("ECharts");
+      if (allDeps["d3"]) features.tools.push("D3.js");
+      if (allDeps["chart.js"]) features.tools.push("Chart.js");
+      if (allDeps["antv"] || allDeps["@antv/g6"]) features.tools.push("AntV");
+      if (allDeps["typescript"]) features.languages.push("TypeScript");
+      if (((_a = packageJson.dependencies) == null ? void 0 : _a["react"]) || ((_b = packageJson.devDependencies) == null ? void 0 : _b["react"])) {
+        features.languages.push("JavaScript");
+      }
+      if (allDeps["vue-i18n"] || allDeps["react-i18n"] || allDeps["i18next"] || allDeps["react-intl"]) {
+        features.keywords.push("i18n");
+      }
+      if (allDeps["pinia"] || allDeps["vuex"] || allDeps["redux"] || allDeps["@reduxjs/toolkit"] || allDeps["mobx"] || allDeps["zustand"] || allDeps["recoil"] || allDeps["jotai"]) {
+        features.keywords.push("state-management");
+      }
+      if (allDeps["vue-router"] || allDeps["react-router"] || allDeps["react-router-dom"] || allDeps["@tanstack/react-router"]) {
+        features.keywords.push("routing");
+      }
+      if (allDeps["axios"] || allDeps["@tanstack/react-query"] || allDeps["@tanstack/vue-query"] || allDeps["swr"] || allDeps["urql"]) {
+        features.keywords.push("data-fetching");
+      }
+      if (allDeps["formik"] || allDeps["react-hook-form"] || allDeps["vee-validate"] || allDeps["@vuelidate/core"]) {
+        features.keywords.push("forms");
+      }
+      if (allDeps["vitest"] || allDeps["jest"] || allDeps["@testing-library/react"] || allDeps["@testing-library/vue"] || allDeps["cypress"] || allDeps["playwright"]) {
+        features.keywords.push("testing");
+      }
+      if (allDeps["vant"] || allDeps["@tarojs/taro"] || allDeps["react-native"] || allDeps["uni-app"] || allDeps["@nutui/nutui"]) {
+        features.keywords.push("mobile");
+      }
+      if (packageJson.miniprogram || allDeps["@tarojs/taro"] || allDeps["uni-app"]) {
+        features.keywords.push("miniprogram");
+        features.keywords.push("wechat");
+      }
+      if (allDeps["prisma"] || allDeps["typeorm"] || allDeps["sequelize"] || allDeps["mongoose"]) {
+        features.keywords.push("database");
+      }
+      if (allDeps["graphql"] || allDeps["apollo-client"] || allDeps["@apollo/client"]) {
+        features.keywords.push("graphql");
+      }
+    } catch (error) {
+      this.log(`\u89E3\u6790 package.json \u5931\u8D25: ${error}`);
+    }
+    return features;
+  }
+  /**
+   * 分析 pubspec.yaml (Flutter 项目)
+   */
+  analyzePubspecYaml(pubspecPath) {
+    const features = {
+      frameworks: ["Flutter"],
+      languages: ["Dart"],
+      tools: [],
+      keywords: []
+    };
+    try {
+      const content = fs.readFileSync(pubspecPath, "utf-8");
+      if (content.includes("provider:")) features.keywords.push("state-management");
+      if (content.includes("riverpod:")) features.keywords.push("state-management");
+      if (content.includes("bloc:") || content.includes("flutter_bloc:")) features.keywords.push("state-management");
+      if (content.includes("get:") || content.includes("get_x:")) {
+        features.keywords.push("routing", "state-management");
+      }
+      if (content.includes("flutter_localizations:") || content.includes("intl:") || content.includes("easy_localization:")) {
+        features.keywords.push("i18n");
+      }
+      if (content.includes("go_router:") || content.includes("auto_route:")) features.keywords.push("routing");
+      if (content.includes("dio:") || content.includes("http:")) features.keywords.push("data-fetching");
+      if (content.includes("flutter_screenutil:")) features.tools.push("ScreenUtil");
+      if (content.includes("flutter_test:") || content.includes("mockito:") || content.includes("integration_test:")) {
+        features.keywords.push("testing");
+      }
+    } catch (error) {
+      this.log(`\u89E3\u6790 pubspec.yaml \u5931\u8D25: ${error}`);
+    }
+    return features;
+  }
+  /**
+   * 分析文件结构
+   */
+  async analyzeFileStructure(rootPath) {
+    const features = {
+      frameworks: [],
+      languages: [],
+      tools: [],
+      keywords: []
+    };
+    try {
+      const patterns = [
+        "**/*.vue",
+        "**/*.ts",
+        "**/*.tsx",
+        "**/*.jsx",
+        "**/*.js",
+        "**/*.py",
+        "**/*.java",
+        "**/*.go",
+        "**/*.rs",
+        "**/*.cpp",
+        "**/*.c",
+        "**/locales/**",
+        "**/i18n/**",
+        "**/lang/**",
+        "**/stores/**",
+        "**/store/**",
+        "**/redux/**",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/components/**",
+        "**/pages/**",
+        "**/views/**"
+      ];
+      const files = await glob(patterns, {
+        cwd: rootPath,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
+        onlyFiles: true
+      });
+      if (files.some((f) => f.endsWith(".vue"))) features.frameworks.push("Vue");
+      if (files.some((f) => f.endsWith(".tsx"))) features.frameworks.push("React");
+      if (files.some((f) => f.endsWith(".svelte"))) features.frameworks.push("Svelte");
+      if (files.some((f) => f.endsWith(".ts") || f.endsWith(".tsx"))) features.languages.push("TypeScript");
+      if (files.some((f) => f.endsWith(".js") || f.endsWith(".jsx"))) features.languages.push("JavaScript");
+      if (files.some((f) => f.endsWith(".py"))) features.languages.push("Python");
+      if (files.some((f) => f.endsWith(".java"))) features.languages.push("Java");
+      if (files.some((f) => f.endsWith(".go"))) features.languages.push("Go");
+      if (files.some((f) => f.endsWith(".rs"))) features.languages.push("Rust");
+      if (files.some((f) => f.match(/\.(cpp|cc|cxx|c)$/))) features.languages.push("C/C++");
+      if (files.some((f) => f.includes("/locales/") || f.includes("/i18n/") || f.includes("/lang/"))) {
+        features.keywords.push("i18n");
+      }
+      if (files.some((f) => f.includes("/stores/") || f.includes("/store/") || f.includes("/redux/"))) {
+        features.keywords.push("state-management");
+      }
+      if (files.some((f) => f.includes(".test.") || f.includes(".spec."))) {
+        features.keywords.push("testing");
+      }
+    } catch (error) {
+      this.log(`\u626B\u63CF\u6587\u4EF6\u7ED3\u6784\u5931\u8D25: ${error}`);
+    }
+    return features;
+  }
+  /**
+   * 匹配 Agents
+   */
+  matchAgents(features, availableAgents) {
+    const scoredAgents = availableAgents.map((agent) => {
+      const score = this.calculateMatchScore(features, agent);
+      return { ...agent, score };
+    });
+    return scoredAgents.filter((a) => a.score > 0).sort((a, b) => (b.score || 0) - (a.score || 0));
+  }
+  /**
+   * 计算匹配分数
+   */
+  calculateMatchScore(features, agent) {
+    let score = 0;
+    const WEIGHTS = {
+      framework: 10,
+      tool: 8,
+      language: 5,
+      keyword: 3,
+      tag: 2
+    };
+    features.frameworks.forEach((f) => {
+      var _a, _b;
+      if ((_b = (_a = agent.applicableWhen) == null ? void 0 : _a.frameworks) == null ? void 0 : _b.some((af) => af.toLowerCase().includes(f.toLowerCase()))) {
+        score += WEIGHTS.framework;
+      }
+    });
+    features.tools.forEach((t) => {
+      var _a, _b;
+      if ((_b = (_a = agent.applicableWhen) == null ? void 0 : _a.tools) == null ? void 0 : _b.some((at) => at.toLowerCase().includes(t.toLowerCase()))) {
+        score += WEIGHTS.tool;
+      }
+    });
+    features.languages.forEach((l) => {
+      var _a, _b;
+      if ((_b = (_a = agent.applicableWhen) == null ? void 0 : _a.languages) == null ? void 0 : _b.some((al) => al.toLowerCase().includes(l.toLowerCase()))) {
+        score += WEIGHTS.language;
+      }
+    });
+    features.keywords.forEach((k) => {
+      var _a, _b;
+      if ((_b = (_a = agent.applicableWhen) == null ? void 0 : _a.keywords) == null ? void 0 : _b.some((ak) => ak.toLowerCase().includes(k.toLowerCase()))) {
+        score += WEIGHTS.keyword;
+      }
+    });
+    features.frameworks.concat(features.tools, features.languages, features.keywords).forEach((feature) => {
+      if (agent.tags.some((tag) => tag.toLowerCase().includes(feature.toLowerCase()))) {
+        score += WEIGHTS.tag;
+      }
+    });
+    return score;
+  }
+  /**
+   * 解析 Agent 元数据
+   */
+  parseAgentMetadata(filePath, content) {
+    const id = path2.basename(filePath, ".agent.md");
+    let description = "";
+    let tags = [];
+    if (content.startsWith("---")) {
+      const endIndex = content.indexOf("---", 3);
+      if (endIndex > 0) {
+        const frontmatter = content.substring(3, endIndex);
+        const descMatch = frontmatter.match(/description:\s*['"](.+)['"]/);
+        if (descMatch) description = descMatch[1];
+        const tagsMatch = frontmatter.match(/tags:\s*\[(.+)\]/);
+        if (tagsMatch) {
+          tags = tagsMatch[1].split(",").map((t) => t.trim().replace(/['"]/g, ""));
+        }
+      }
+    }
+    const titleMatch = content.match(/^#\s+(.+)$/m);
+    const title = titleMatch ? titleMatch[1] : id;
+    return {
+      id,
+      path: filePath,
+      title,
+      description,
+      tags,
+      applicableWhen: {
+        frameworks: tags.filter(
+          (t) => [
+            "vue",
+            "vue3",
+            "react",
+            "angular",
+            "next",
+            "nuxt",
+            "svelte",
+            "flutter",
+            "express",
+            "nestjs",
+            "koa",
+            "fastify"
+          ].includes(t.toLowerCase())
+        ),
+        languages: tags.filter(
+          (t) => ["typescript", "javascript", "python", "java", "go", "rust", "dart", "c++"].includes(t.toLowerCase())
+        ),
+        tools: tags.filter(
+          (t) => [
+            "vite",
+            "webpack",
+            "rollup",
+            "logicflow",
+            "element-plus",
+            "antd",
+            "tailwind",
+            "sass",
+            "echarts",
+            "prisma",
+            "graphql"
+          ].includes(t.toLowerCase())
+        ),
+        keywords: tags.filter(
+          (t) => [
+            "i18n",
+            "state-management",
+            "routing",
+            "testing",
+            "mobile",
+            "miniprogram",
+            "database",
+            "forms",
+            "data-fetching"
+          ].includes(t.toLowerCase())
+        )
+      }
+    };
+  }
+  mergeFeatures(target, source) {
+    if (source.frameworks) target.frameworks.push(...source.frameworks);
+    if (source.languages) target.languages.push(...source.languages);
+    if (source.tools) target.tools.push(...source.tools);
+    if (source.keywords) target.keywords.push(...source.keywords);
+  }
+  inferProjectType(features) {
+    if (features.frameworks.some((f) => f.toLowerCase().includes("vue"))) return "vue3";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("react"))) return "react";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("angular"))) return "angular";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("svelte"))) return "svelte";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("next"))) return "nextjs";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("nuxt"))) return "nuxtjs";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("flutter"))) return "flutter";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("react-native"))) return "react-native";
+    if (features.keywords.includes("miniprogram")) return "miniprogram";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("nest"))) return "nestjs";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("express"))) return "express";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("koa"))) return "koa";
+    if (features.frameworks.some((f) => f.toLowerCase().includes("fastify"))) return "fastify";
+    if (features.languages.includes("TypeScript")) return "typescript";
+    if (features.languages.includes("Python")) return "python";
+    if (features.languages.includes("Java")) return "java";
+    if (features.languages.includes("Go")) return "go";
+    if (features.languages.includes("Rust")) return "rust";
+    return "general";
+  }
+  log(message) {
+    var _a;
+    (_a = this.logger) == null ? void 0 : _a.log(message);
+  }
+};
+
+// src/core/i18nDetector.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+import glob2 from "fast-glob";
+var I18nDetector = class {
+  /**
+   * 检测项目的国际化配置
+   */
+  static async detect(projectPath) {
+    const packageJsonPath = path3.join(projectPath, "package.json");
+    if (fs2.existsSync(packageJsonPath)) {
+      return this.detectFrontendI18n(projectPath, packageJsonPath);
+    }
+    const pubspecPath = path3.join(projectPath, "pubspec.yaml");
+    if (fs2.existsSync(pubspecPath)) {
+      return this.detectFlutterI18n(projectPath, pubspecPath);
+    }
+    return {
+      enabled: false,
+      type: "none",
+      configFiles: [],
+      messageFiles: [],
+      method: "",
+      example: "",
+      tips: ["\u9879\u76EE\u672A\u914D\u7F6E\u56FD\u9645\u5316\uFF0C\u5EFA\u8BAE\u6DFB\u52A0\u4E2D\u82F1\u53CC\u8BED\u652F\u6301"]
+    };
+  }
+  /**
+   * 检测前端项目的国际化配置（Vue/React）
+   */
+  static detectFrontendI18n(projectPath, packageJsonPath) {
+    const content = fs2.readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    if (allDeps["vue-i18n"]) {
+      return this.detectVueI18n(projectPath);
+    }
+    if (allDeps["react-i18next"] || allDeps["i18next"]) {
+      return this.detectReactI18n(projectPath);
+    }
+    if (allDeps["react-intl"]) {
+      return this.detectReactIntl(projectPath);
+    }
+    return this.detectCustomI18n(projectPath);
+  }
+  /**
+   * 检测 vue-i18n 配置
+   */
+  static detectVueI18n(projectPath) {
+    const configFiles = [];
+    const messageFiles = [];
+    const possibleConfigPaths = [
+      "src/i18n/index.ts",
+      "src/i18n/index.js",
+      "src/locales/index.ts",
+      "src/locales/index.js",
+      "i18n.config.ts",
+      "i18n.config.js"
+    ];
+    for (const configPath of possibleConfigPaths) {
+      const fullPath = path3.join(projectPath, configPath);
+      if (fs2.existsSync(fullPath)) {
+        configFiles.push(configPath);
+      }
+    }
+    const possibleMessageDirs = ["src/i18n", "src/locales", "src/lang"];
+    for (const dir of possibleMessageDirs) {
+      const fullDir = path3.join(projectPath, dir);
+      if (fs2.existsSync(fullDir)) {
+        const files = fs2.readdirSync(fullDir);
+        for (const file of files) {
+          if (/^(zh|en|ja|ko|fr|de|es).*\.(ts|js|json)$/.test(file)) {
+            messageFiles.push(path3.join(dir, file));
+          }
+        }
+      }
+    }
+    return {
+      enabled: true,
+      type: "vue-i18n",
+      configFiles,
+      messageFiles,
+      method: "$t()",
+      example: `{{ $t('common.save') }} \u6216 :label="$t('user.username')"`,
+      tips: [
+        '\u4F7F\u7528\u547D\u540D\u7A7A\u95F4\u683C\u5F0F\uFF1A$t("common.save")',
+        "\u6240\u6709\u6309\u94AE\u3001\u6807\u7B7E\u3001\u63D0\u793A\u6587\u5B57\u5FC5\u987B\u4F7F\u7528 $t()",
+        "\u8868\u5355\u9A8C\u8BC1\u89C4\u5219\u7684 message \u4E5F\u9700\u8981\u56FD\u9645\u5316",
+        "\u786E\u4FDD zh-CN.ts \u548C en-US.ts \u4E2D\u7684\u952E\u540D\u5B8C\u5168\u4E00\u81F4"
+      ]
+    };
+  }
+  /**
+   * 检测 react-i18next 配置
+   */
+  static detectReactI18n(projectPath) {
+    const configFiles = [];
+    const messageFiles = [];
+    const possibleConfigPaths = [
+      "src/i18n.ts",
+      "src/i18n.js",
+      "src/i18n/config.ts",
+      "src/i18n/config.js"
+    ];
+    for (const configPath of possibleConfigPaths) {
+      const fullPath = path3.join(projectPath, configPath);
+      if (fs2.existsSync(fullPath)) {
+        configFiles.push(configPath);
+      }
+    }
+    const possibleMessageDirs = ["public/locales", "src/locales", "src/i18n"];
+    for (const dir of possibleMessageDirs) {
+      const fullDir = path3.join(projectPath, dir);
+      if (fs2.existsSync(fullDir)) {
+        const pattern = path3.join(fullDir, "**/*.json");
+        try {
+          const files = glob2.sync(pattern);
+          messageFiles.push(...files.map((f) => path3.relative(projectPath, f)));
+        } catch (e) {
+        }
+      }
+    }
+    return {
+      enabled: true,
+      type: "react-i18n",
+      configFiles,
+      messageFiles,
+      method: "t() \u6216 useTranslation()",
+      example: `{t('common.save')} \u6216 const { t } = useTranslation()`,
+      tips: [
+        "\u4F7F\u7528 useTranslation() hook \u83B7\u53D6 t \u51FD\u6570",
+        '\u547D\u540D\u7A7A\u95F4\u683C\u5F0F\uFF1At("common.save")',
+        "\u6240\u6709\u6587\u6848\u5FC5\u987B\u901A\u8FC7 t() \u51FD\u6570\u5305\u88F9",
+        "\u786E\u4FDD\u6240\u6709\u8BED\u8A00\u7684\u7FFB\u8BD1\u6587\u4EF6\u540C\u6B65\u66F4\u65B0"
+      ]
+    };
+  }
+  /**
+   * 检测 react-intl 配置
+   */
+  static detectReactIntl(projectPath) {
+    return {
+      enabled: true,
+      type: "react-i18n",
+      configFiles: [],
+      messageFiles: [],
+      method: "formatMessage() \u6216 FormattedMessage",
+      example: `<FormattedMessage id="common.save" /> \u6216 intl.formatMessage({ id: 'common.save' })`,
+      tips: [
+        "\u4F7F\u7528 FormattedMessage \u7EC4\u4EF6\u6216 formatMessage \u65B9\u6CD5",
+        "\u6D88\u606F ID \u683C\u5F0F\uFF1Acommon.save",
+        "\u6240\u6709\u6587\u6848\u5FC5\u987B\u5B9A\u4E49\u5728\u6D88\u606F\u6587\u4EF6\u4E2D",
+        "\u786E\u4FDD\u591A\u8BED\u8A00\u6587\u4EF6\u7684\u6D88\u606F ID \u4FDD\u6301\u4E00\u81F4"
+      ]
+    };
+  }
+  /**
+   * 检测自定义国际化方案
+   */
+  static detectCustomI18n(projectPath) {
+    const messageFiles = [];
+    const possibleDirs = ["src/locales", "src/i18n", "src/lang"];
+    for (const dir of possibleDirs) {
+      const fullDir = path3.join(projectPath, dir);
+      if (fs2.existsSync(fullDir)) {
+        const files = fs2.readdirSync(fullDir);
+        for (const file of files) {
+          if (/messages?\.(ts|js)$/i.test(file)) {
+            messageFiles.push(path3.join(dir, file));
+            const content = fs2.readFileSync(path3.join(fullDir, file), "utf-8");
+            if (content.includes("[") && content.includes("],")) {
+              return {
+                enabled: true,
+                type: "custom",
+                configFiles: [],
+                messageFiles,
+                method: "$t()",
+                example: `{{ $t('\u4FDD\u5B58') }} \u6216 :label="$t('\u7528\u6237\u540D')"`,
+                tips: [
+                  '\u4F7F\u7528\u76F4\u63A5\u952E\u540D\u683C\u5F0F\uFF1A$t("\u4FDD\u5B58")',
+                  "\u6240\u6709\u6309\u94AE\u3001\u6807\u7B7E\u3001\u63D0\u793A\u6587\u5B57\u5FC5\u987B\u4F7F\u7528 $t()",
+                  "\u8868\u5355\u9A8C\u8BC1\u89C4\u5219\u7684 message \u4E5F\u9700\u8981\u56FD\u9645\u5316",
+                  "\u65B0\u589E\u6587\u6848\u65F6\u9700\u8981\u540C\u65F6\u6DFB\u52A0\u4E2D\u82F1\u6587\u7FFB\u8BD1"
+                ]
+              };
+            }
+          }
+        }
+      }
+    }
+    if (messageFiles.length > 0) {
+      return {
+        enabled: true,
+        type: "custom",
+        configFiles: [],
+        messageFiles,
+        method: "$t()",
+        example: "\u8BF7\u67E5\u770B\u9879\u76EE\u4E2D\u73B0\u6709\u9875\u9762\u7684\u4F7F\u7528\u65B9\u5F0F",
+        tips: [
+          "\u68C0\u6D4B\u5230\u56FD\u9645\u5316\u6587\u4EF6\uFF0C\u4F46\u683C\u5F0F\u672A\u77E5",
+          "\u8BF7\u67E5\u770B\u73B0\u6709\u9875\u9762\u786E\u8BA4\u4F7F\u7528\u65B9\u5F0F",
+          "\u786E\u4FDD\u6240\u6709\u65B0\u589E\u6587\u6848\u90FD\u9075\u5FAA\u9879\u76EE\u89C4\u8303"
+        ]
+      };
+    }
+    return {
+      enabled: false,
+      type: "none",
+      configFiles: [],
+      messageFiles: [],
+      method: "",
+      example: "",
+      tips: [
+        "\u26A0\uFE0F \u9879\u76EE\u672A\u914D\u7F6E\u56FD\u9645\u5316",
+        "\u5EFA\u8BAE\u6DFB\u52A0\u4E2D\u82F1\u53CC\u8BED\u652F\u6301",
+        "\u63A8\u8350\u4F7F\u7528 vue-i18n\uFF08Vue\uFF09\u6216 react-i18next\uFF08React\uFF09"
+      ]
+    };
+  }
+  /**
+   * 检测 Flutter 项目的国际化配置
+   */
+  static detectFlutterI18n(projectPath, pubspecPath) {
+    const content = fs2.readFileSync(pubspecPath, "utf-8");
+    if (content.includes("flutter_localizations")) {
+      const messageFiles = [];
+      const l10nDir = path3.join(projectPath, "lib", "l10n");
+      if (fs2.existsSync(l10nDir)) {
+        const files = fs2.readdirSync(l10nDir);
+        for (const file of files) {
+          if (file.endsWith(".arb")) {
+            messageFiles.push(`lib/l10n/${file}`);
+          }
+        }
+      }
+      const l10nConfigPath = path3.join(projectPath, "l10n.yaml");
+      const configFiles = fs2.existsSync(l10nConfigPath) ? ["l10n.yaml"] : [];
+      return {
+        enabled: true,
+        type: "flutter-intl",
+        configFiles,
+        messageFiles,
+        method: "AppLocalizations",
+        example: `AppLocalizations.of(context)!.save \u6216 S.of(context).save`,
+        tips: [
+          "\u4F7F\u7528 AppLocalizations.of(context)!.key",
+          "\u6240\u6709\u6587\u672C\u5FC5\u987B\u5728 .arb \u6587\u4EF6\u4E2D\u5B9A\u4E49",
+          "\u786E\u4FDD app_en.arb \u548C app_zh.arb \u7684\u952E\u540D\u5B8C\u5168\u4E00\u81F4",
+          "\u8FD0\u884C flutter gen-l10n \u751F\u6210\u4EE3\u7801"
+        ]
+      };
+    }
+    if (content.includes("easy_localization")) {
+      return {
+        enabled: true,
+        type: "flutter-intl",
+        configFiles: [],
+        messageFiles: [],
+        method: "tr()",
+        example: `'save'.tr() \u6216 Text('save'.tr())`,
+        tips: [
+          "\u4F7F\u7528 .tr() \u6269\u5C55\u65B9\u6CD5",
+          "\u7FFB\u8BD1\u6587\u4EF6\u901A\u5E38\u5728 assets/translations/",
+          "\u786E\u4FDD\u6240\u6709\u8BED\u8A00\u6587\u4EF6\u7684\u952E\u540D\u4E00\u81F4"
+        ]
+      };
+    }
+    return {
+      enabled: false,
+      type: "none",
+      configFiles: [],
+      messageFiles: [],
+      method: "",
+      example: "",
+      tips: [
+        "\u26A0\uFE0F Flutter \u9879\u76EE\u672A\u914D\u7F6E\u56FD\u9645\u5316",
+        "\u5EFA\u8BAE\u6DFB\u52A0 flutter_localizations",
+        "\u5728 pubspec.yaml \u4E2D\u6DFB\u52A0\uFF1A",
+        "  flutter_localizations:",
+        "    sdk: flutter",
+        "  intl: any"
+      ]
+    };
+  }
+};
+
+// src/core/types.ts
+var ConsoleLogger = class {
+  constructor(enableDebug = false) {
+    this.enableDebug = enableDebug;
+  }
+  log(message) {
+    console.error(`[MCP] [INFO] ${message}`);
+  }
+  error(message) {
+    console.error(`[MCP] [ERROR] ${message}`);
+  }
+  debug(message) {
+    if (this.enableDebug) {
+      console.error(`[MCP] [DEBUG] ${message}`);
+    }
+  }
+};
+
+// src/tools/analyzeProject.ts
+async function analyzeProject(args) {
+  const logger3 = new ConsoleLogger();
+  try {
+    let projectPath = args.projectPath;
+    if (!projectPath) {
+      projectPath = process.cwd();
+      logger3.log(`\u{1F4CD} \u672A\u6307\u5B9A\u8DEF\u5F84\uFF0C\u4F7F\u7528\u5F53\u524D\u76EE\u5F55: ${projectPath}`);
+    }
+    if (!fs3.existsSync(projectPath)) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: `\u9879\u76EE\u8DEF\u5F84\u4E0D\u5B58\u5728: ${projectPath}`
+          }, null, 2)
+        }]
+      };
+    }
+    const matcher = new SmartAgentMatcher(logger3);
+    const workspaceFolder = {
+      uri: { fsPath: projectPath },
+      name: path4.basename(projectPath),
+      index: 0
+    };
+    const features = await matcher.analyzeProject(workspaceFolder);
+    logger3.log(`\u{1F30D} \u68C0\u6D4B\u56FD\u9645\u5316\u914D\u7F6E...`);
+    const i18nConfig = await I18nDetector.detect(projectPath);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          projectPath,
+          projectName: path4.basename(projectPath),
+          autoDetected: !args.projectPath,
+          features: {
+            projectType: features.projectType,
+            frameworks: features.frameworks,
+            languages: features.languages,
+            tools: features.tools,
+            keywords: features.keywords
+          },
+          i18n: {
+            enabled: i18nConfig.enabled,
+            type: i18nConfig.type,
+            configFiles: i18nConfig.configFiles,
+            messageFiles: i18nConfig.messageFiles,
+            method: i18nConfig.method,
+            example: i18nConfig.example,
+            tips: i18nConfig.tips
+          },
+          summary: `\u68C0\u6D4B\u5230 ${features.projectType} \u9879\u76EE\uFF0C\u4F7F\u7528 ${features.frameworks.join(", ")} \u6846\u67B6\u3002\u56FD\u9645\u5316\uFF1A${i18nConfig.enabled ? `\u5DF2\u914D\u7F6E (${i18nConfig.type})` : "\u672A\u914D\u7F6E"}`
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u5206\u6790\u9879\u76EE\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// src/core/githubClient.ts
+import axios from "axios";
+var GitHubClient = class {
+  constructor(logger3) {
+    this.logger = logger3;
+    this.owner = "ForLear";
+    this.repo = "copilot-prompts";
+    this.branch = "main";
+    this.baseUrl = "https://api.github.com";
+    this.rawBaseUrl = "https://raw.githubusercontent.com";
+  }
+  /**
+   * 列出目录中的文件
+   */
+  async listDirectoryFiles(dirPath) {
+    var _a;
+    const url = `${this.baseUrl}/repos/${this.owner}/${this.repo}/contents/${dirPath}?ref=${this.branch}`;
+    try {
+      const response = await axios.get(url, {
+        headers: {
+          "Accept": "application/vnd.github.v3+json",
+          "User-Agent": "Copilot-Prompts-MCP-Server"
+        }
+      });
+      if (Array.isArray(response.data)) {
+        return response.data.map((item) => ({
+          name: item.name,
+          path: item.path,
+          type: item.type
+        }));
+      }
+      return [];
+    } catch (error) {
+      (_a = this.logger) == null ? void 0 : _a.error(`\u83B7\u53D6\u76EE\u5F55\u5931\u8D25: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * 获取文件内容
+   */
+  async fetchFileContent(filePath) {
+    var _a;
+    const url = `${this.rawBaseUrl}/${this.owner}/${this.repo}/${this.branch}/${filePath}`;
+    try {
+      const response = await axios.get(url, {
+        headers: {
+          "User-Agent": "Copilot-Prompts-MCP-Server"
+        }
+      });
+      return response.data;
+    } catch (error) {
+      (_a = this.logger) == null ? void 0 : _a.error(`\u83B7\u53D6\u6587\u4EF6\u5931\u8D25: ${filePath}`);
+      throw error;
+    }
+  }
+};
+
+// src/tools/matchAgents.ts
+async function matchAgents(args) {
+  const logger3 = new ConsoleLogger();
+  try {
+    const matcher = new SmartAgentMatcher(logger3);
+    const githubClient = new GitHubClient(logger3);
+    logger3.log("\u6B63\u5728\u4ECE GitHub \u83B7\u53D6\u53EF\u7528 Agents...");
+    const availableAgents = [];
+    try {
+      const agentFiles = await githubClient.listDirectoryFiles("agents");
+      for (const file of agentFiles) {
+        if (file.name.endsWith(".agent.md")) {
+          try {
+            const content = await githubClient.fetchFileContent(file.path);
+            const metadata = matcher.parseAgentMetadata(file.path, content);
+            availableAgents.push(metadata);
+          } catch (error) {
+            logger3.error(`\u89E3\u6790 ${file.name} \u5931\u8D25: ${error}`);
+          }
+        }
+      }
+    } catch (error) {
+      logger3.error(`\u83B7\u53D6 Agents \u5931\u8D25: ${error}`);
+    }
+    const matchedAgents = matcher.matchAgents(args.projectFeatures, availableAgents);
+    const limit = args.limit || 10;
+    const topAgents = matchedAgents.slice(0, limit);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          totalAvailable: availableAgents.length,
+          matched: topAgents.length,
+          agents: topAgents.map((agent) => ({
+            id: agent.id,
+            title: agent.title,
+            description: agent.description,
+            score: agent.score,
+            tags: agent.tags,
+            path: agent.path
+          })),
+          recommendations: topAgents.slice(0, 5).map((a) => a.title)
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u5339\u914D Agents \u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// src/tools/listAgents.ts
+async function listAvailableAgents() {
+  const logger3 = new ConsoleLogger();
+  try {
+    const githubClient = new GitHubClient(logger3);
+    logger3.log("\u6B63\u5728\u4ECE GitHub \u83B7\u53D6 Agents \u5217\u8868...");
+    const agentFiles = await githubClient.listDirectoryFiles("agents");
+    const agents = agentFiles.filter((f) => f.name.endsWith(".agent.md"));
+    const agentList = await Promise.all(
+      agents.map(async (file) => {
+        try {
+          const content = await githubClient.fetchFileContent(file.path);
+          const lines = content.split("\n");
+          let title = file.name.replace(".agent.md", "");
+          let description = "";
+          if (lines[0] === "---") {
+            const endIndex = lines.slice(1).findIndex((l) => l === "---");
+            if (endIndex > 0) {
+              const frontmatter = lines.slice(1, endIndex + 1).join("\n");
+              const descMatch = frontmatter.match(/description:\s*['"](.+)['"]/);
+              if (descMatch) {
+                description = descMatch[1];
+              }
+            }
+          }
+          const titleLine = lines.find((l) => l.startsWith("# "));
+          if (titleLine) {
+            title = titleLine.replace("# ", "").trim();
+          }
+          return {
+            id: file.name.replace(".agent.md", ""),
+            name: file.name,
+            title,
+            description: description || "\u6682\u65E0\u63CF\u8FF0",
+            path: file.path
+          };
+        } catch (error) {
+          logger3.error(`\u89E3\u6790 ${file.name} \u5931\u8D25: ${error}`);
+          return null;
+        }
+      })
+    );
+    const validAgents = agentList.filter((a) => a !== null);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          total: validAgents.length,
+          agents: validAgents,
+          categories: {
+            general: validAgents.filter((a) => a.path.includes("common/")).length,
+            frameworks: validAgents.filter((a) => a.path.includes("vue/") || a.path.includes("react/")).length,
+            agents: validAgents.filter((a) => a.path.includes("agents/")).length
+          }
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u83B7\u53D6 Agents \u5217\u8868\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// src/tools/generateConfig.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/core/codeValidator.ts
+var CodeValidator = class {
+  constructor(logger3) {
+    this.logger = logger3 || new ConsoleLogger();
+  }
+  /**
+   * 验证生成的配置文件内容
+   */
+  validateConfigContent(content) {
+    const errors = [];
+    const warnings = [];
+    this.checkDuplicateTags(content, errors);
+    this.checkBracketMatching(content, errors);
+    this.checkMarkdownSyntax(content, errors);
+    this.checkRequiredSections(content, warnings);
+    this.checkCustomContentMarkers(content, warnings);
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * 检查重复的HTML标签
+   */
+  checkDuplicateTags(content, errors) {
+    const lines = content.split("\n");
+    const tagPattern = /<\/([\w-]+)>/g;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const matches = Array.from(line.matchAll(tagPattern));
+      if (matches.length > 0) {
+        const tags = matches.map((m) => m[1]);
+        const tagCounts = /* @__PURE__ */ new Map();
+        tags.forEach((tag) => {
+          tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+        });
+        tagCounts.forEach((count, tag) => {
+          if (count > 1) {
+            errors.push({
+              type: "syntax",
+              message: `\u91CD\u590D\u7684\u95ED\u5408\u6807\u7B7E </${tag}> \u5728\u540C\u4E00\u884C\u51FA\u73B0 ${count} \u6B21`,
+              line: i + 1,
+              suggestion: `\u68C0\u67E5\u662F\u5426\u6709\u591A\u4F59\u7684\u95ED\u5408\u6807\u7B7E\uFF0C\u5E94\u8BE5\u53EA\u4FDD\u7559\u4E00\u4E2A </${tag}>`
+            });
+          }
+        });
+      }
+    }
+  }
+  /**
+   * 检查括号匹配
+   */
+  checkBracketMatching(content, errors) {
+    const brackets = {
+      "(": ")",
+      "[": "]",
+      "{": "}",
+      "<": ">"
+    };
+    const stack = [];
+    const lines = content.split("\n");
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      if (line.trim().startsWith("```")) {
+        continue;
+      }
+      if (line.trim().startsWith(">")) {
+        continue;
+      }
+      for (let col = 0; col < line.length; col++) {
+        const char = line[col];
+        if (char === ">" && (col === 0 || line[col - 1] === " ") && (col === line.length - 1 || line[col + 1] === " ")) {
+          continue;
+        }
+        if (char in brackets) {
+          stack.push({ char, line: lineNum + 1, col: col + 1 });
+        } else if (Object.values(brackets).includes(char)) {
+          if (stack.length === 0) {
+            errors.push({
+              type: "syntax",
+              message: `\u672A\u914D\u5BF9\u7684\u95ED\u5408\u62EC\u53F7 '${char}'`,
+              line: lineNum + 1,
+              suggestion: `\u68C0\u67E5\u662F\u5426\u7F3A\u5C11\u5BF9\u5E94\u7684\u5F00\u653E\u62EC\u53F7`
+            });
+          } else {
+            const last = stack.pop();
+            const expectedClose = brackets[last.char];
+            if (char !== expectedClose) {
+              errors.push({
+                type: "syntax",
+                message: `\u62EC\u53F7\u4E0D\u5339\u914D: \u671F\u671B '${expectedClose}' \u4F46\u5F97\u5230 '${char}'`,
+                line: lineNum + 1,
+                suggestion: `\u68C0\u67E5\u7B2C ${last.line} \u884C\u7684 '${last.char}' \u5BF9\u5E94\u7684\u95ED\u5408\u62EC\u53F7`
+              });
+            }
+          }
+        }
+      }
+    }
+    if (stack.length > 0) {
+      stack.forEach((bracket) => {
+        errors.push({
+          type: "syntax",
+          message: `\u672A\u95ED\u5408\u7684\u62EC\u53F7 '${bracket.char}'`,
+          line: bracket.line,
+          suggestion: `\u6DFB\u52A0\u5BF9\u5E94\u7684\u95ED\u5408\u62EC\u53F7 '${brackets[bracket.char]}'`
+        });
+      });
+    }
+  }
+  /**
+   * 检查 Markdown 语法
+   */
+  checkMarkdownSyntax(content, errors) {
+    const lines = content.split("\n");
+    let inCodeBlock = false;
+    let codeBlockStart = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim().startsWith("```")) {
+        if (inCodeBlock) {
+          inCodeBlock = false;
+        } else {
+          inCodeBlock = true;
+          codeBlockStart = i + 1;
+        }
+      }
+    }
+    if (inCodeBlock) {
+      errors.push({
+        type: "syntax",
+        message: "\u672A\u95ED\u5408\u7684\u4EE3\u7801\u5757",
+        line: codeBlockStart,
+        suggestion: "\u5728\u4EE3\u7801\u5757\u672B\u5C3E\u6DFB\u52A0 ``` \u95ED\u5408\u6807\u8BB0"
+      });
+    }
+  }
+  /**
+   * 检查必要章节完整性
+   */
+  checkRequiredSections(content, warnings) {
+    const requiredSections = [
+      { pattern: /## ⚠️ 强制工作流/i, name: "\u5F3A\u5236\u5DE5\u4F5C\u6D41\u7AE0\u8282" },
+      { pattern: /## 📚 配置的 Agents/i, name: "Agents \u914D\u7F6E\u7AE0\u8282" }
+    ];
+    requiredSections.forEach((section) => {
+      if (!section.pattern.test(content)) {
+        warnings.push({
+          type: "completeness",
+          message: `\u7F3A\u5C11\u5FC5\u8981\u7AE0\u8282: ${section.name}`,
+          suggestion: "\u786E\u4FDD\u751F\u6210\u7684\u914D\u7F6E\u6587\u4EF6\u5305\u542B\u6240\u6709\u5FC5\u8981\u7684\u7AE0\u8282"
+        });
+      }
+    });
+  }
+  /**
+   * 检查自定义内容标记
+   */
+  checkCustomContentMarkers(content, warnings) {
+    const hasCustomStart = content.includes("<!-- CUSTOM_START -->");
+    const hasCustomEnd = content.includes("<!-- CUSTOM_END -->");
+    if (hasCustomStart !== hasCustomEnd) {
+      warnings.push({
+        type: "completeness",
+        message: "CUSTOM \u6807\u8BB0\u4E0D\u5B8C\u6574",
+        suggestion: "\u786E\u4FDD CUSTOM_START \u548C CUSTOM_END \u6210\u5BF9\u51FA\u73B0"
+      });
+    }
+  }
+  /**
+   * 验证 Agent 内容
+   */
+  validateAgentContent(content, agentId) {
+    const errors = [];
+    const warnings = [];
+    if (!content.includes("\u26A0\uFE0F \u5F3A\u5236\u5DE5\u4F5C\u6D41") && !content.includes("## \u5F3A\u5236\u5DE5\u4F5C\u6D41")) {
+      warnings.push({
+        type: "best-practice",
+        message: `Agent ${agentId} \u7F3A\u5C11\u5F3A\u5236\u5DE5\u4F5C\u6D41\u8BF4\u660E`,
+        suggestion: "\u5EFA\u8BAE\u5728 Agent \u4E2D\u5305\u542B MCP \u5DE5\u5177\u8C03\u7528\u7684\u5F3A\u5236\u8BF4\u660E"
+      });
+    }
+    const syntaxValidation = this.validateConfigContent(content);
+    errors.push(...syntaxValidation.errors);
+    warnings.push(...syntaxValidation.warnings);
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * 生成验证报告
+   */
+  generateValidationReport(result) {
+    let report = "";
+    if (result.isValid && result.warnings.length === 0) {
+      report = "\u2705 \u9A8C\u8BC1\u901A\u8FC7\uFF0C\u672A\u53D1\u73B0\u95EE\u9898\n";
+      return report;
+    }
+    if (!result.isValid) {
+      report += "\u274C \u9A8C\u8BC1\u5931\u8D25\uFF0C\u53D1\u73B0\u4EE5\u4E0B\u9519\u8BEF\uFF1A\n\n";
+      result.errors.forEach((error, index) => {
+        report += `${index + 1}. [${error.type}] ${error.message}
+`;
+        if (error.line) {
+          report += `   \u4F4D\u7F6E: \u7B2C ${error.line} \u884C
+`;
+        }
+        if (error.suggestion) {
+          report += `   \u5EFA\u8BAE: ${error.suggestion}
+`;
+        }
+        report += "\n";
+      });
+    } else {
+      report += "\u2705 \u9A8C\u8BC1\u901A\u8FC7\n\n";
+    }
+    if (result.warnings.length > 0) {
+      report += "\u26A0\uFE0F \u53D1\u73B0\u4EE5\u4E0B\u8B66\u544A\uFF1A\n\n";
+      result.warnings.forEach((warning, index) => {
+        report += `${index + 1}. [${warning.type}] ${warning.message}
+`;
+        if (warning.suggestion) {
+          report += `   \u5EFA\u8BAE: ${warning.suggestion}
+`;
+        }
+        report += "\n";
+      });
+    }
+    return report;
+  }
+  /**
+   * 尝试自动修复简单的语法错误
+   */
+  attemptAutoFix(content) {
+    let fixedContent = content;
+    const changes = [];
+    const tagPattern = /(<\/([\w-]+)>)\1+/g;
+    const tagMatches = content.match(tagPattern);
+    if (tagMatches) {
+      fixedContent = fixedContent.replace(tagPattern, "$1");
+      changes.push(`\u4FEE\u590D\u4E86\u91CD\u590D\u7684\u95ED\u5408\u6807\u7B7E: ${tagMatches.join(", ")}`);
+    }
+    const codeBlockCount = (fixedContent.match(/```/g) || []).length;
+    if (codeBlockCount % 2 !== 0) {
+      fixedContent += "\n```\n";
+      changes.push("\u6DFB\u52A0\u4E86\u7F3A\u5931\u7684\u4EE3\u7801\u5757\u95ED\u5408\u6807\u8BB0");
+    }
+    return {
+      fixed: changes.length > 0,
+      content: fixedContent,
+      changes
+    };
+  }
+};
+
+// src/tools/generateConfig.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
+async function generateConfig(args) {
+  const logger3 = new ConsoleLogger();
+  try {
+    if (!fs4.existsSync(args.projectPath)) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: `\u9879\u76EE\u8DEF\u5F84\u4E0D\u5B58\u5728: ${args.projectPath}`
+          }, null, 2)
+        }]
+      };
+    }
+    const matcher = new SmartAgentMatcher(logger3);
+    const githubClient = new GitHubClient(logger3);
+    let selectedAgents = [];
+    if (args.autoMatch !== false) {
+      logger3.log("\u6B63\u5728\u5206\u6790\u9879\u76EE\u7279\u5F81...");
+      const workspaceFolder = {
+        uri: { fsPath: args.projectPath },
+        name: path5.basename(args.projectPath),
+        index: 0
+      };
+      const features = await matcher.analyzeProject(workspaceFolder);
+      logger3.log("\u6B63\u5728\u5339\u914D Agents...");
+      const availableAgents = [];
+      try {
+        logger3.log("\u{1F4E1} \u4ECE GitHub \u83B7\u53D6 Agents...");
+        const agentFiles = await githubClient.listDirectoryFiles("agents");
+        for (const file of agentFiles) {
+          if (file.name.endsWith(".agent.md")) {
+            try {
+              const content2 = await githubClient.fetchFileContent(file.path);
+              const metadata = matcher.parseAgentMetadata(file.path, content2);
+              availableAgents.push(metadata);
+              logger3.log(`\u2705 \u52A0\u8F7D Agent: ${metadata.title}`);
+            } catch (error) {
+              logger3.error(`\u89E3\u6790 ${file.name} \u5931\u8D25`);
+            }
+          }
+        }
+        logger3.log(`\u2705 \u4ECE GitHub \u6210\u529F\u52A0\u8F7D ${availableAgents.length} \u4E2A Agents`);
+      } catch (githubError) {
+        logger3.log("\u26A0\uFE0F GitHub \u83B7\u53D6\u5931\u8D25\uFF0C\u5C1D\u8BD5\u4ECE\u672C\u5730\u52A0\u8F7D...");
+        const agentsDir = path5.join(__dirname2, "../../../agents");
+        if (fs4.existsSync(agentsDir)) {
+          const agentFiles = fs4.readdirSync(agentsDir);
+          logger3.log(`\u627E\u5230 ${agentFiles.length} \u4E2A\u672C\u5730\u6587\u4EF6`);
+          for (const file of agentFiles) {
+            if (file.endsWith(".agent.md")) {
+              try {
+                const filePath = path5.join(agentsDir, file);
+                const content2 = fs4.readFileSync(filePath, "utf-8");
+                const metadata = matcher.parseAgentMetadata(`agents/${file}`, content2);
+                availableAgents.push(metadata);
+                logger3.log(`\u2705 \u52A0\u8F7D Agent: ${metadata.title}`);
+              } catch (error) {
+                logger3.error(`\u89E3\u6790 ${file} \u5931\u8D25`);
+              }
+            }
+          }
+          logger3.log(`\u2705 \u4ECE\u672C\u5730\u6210\u529F\u52A0\u8F7D ${availableAgents.length} \u4E2A Agents`);
+        } else {
+          throw new Error("\u65E0\u6CD5\u4ECE GitHub \u6216\u672C\u5730\u83B7\u53D6 Agents");
+        }
+      }
+      logger3.log(`\u6210\u529F\u52A0\u8F7D ${availableAgents.length} \u4E2A Agents`);
+      selectedAgents = matcher.matchAgents(features, availableAgents);
+      logger3.log(`\u5339\u914D\u5230 ${selectedAgents.length} \u4E2A Agents`);
+      selectedAgents = selectedAgents.slice(0, 5);
+    }
+    if (args.agentIds && args.agentIds.length > 0) {
+      logger3.log(`\u4F7F\u7528\u6307\u5B9A\u7684 Agents: ${args.agentIds.join(", ")}`);
+      selectedAgents = [];
+      for (const id of args.agentIds) {
+        try {
+          let content2;
+          const agentPath = `agents/${id}.agent.md`;
+          try {
+            logger3.log(`\u4ECE GitHub \u83B7\u53D6 Agent: ${id}`);
+            content2 = await githubClient.fetchFileContent(agentPath);
+            logger3.log(`\u2705 \u4ECE GitHub \u52A0\u8F7D\u6210\u529F: ${id}`);
+          } catch (githubError) {
+            logger3.log(`GitHub \u83B7\u53D6\u5931\u8D25\uFF0C\u5C1D\u8BD5\u672C\u5730: ${id}`);
+            const agentsDir = path5.join(__dirname2, "../../../agents");
+            const localPath = path5.join(agentsDir, `${id}.agent.md`);
+            if (fs4.existsSync(localPath)) {
+              content2 = fs4.readFileSync(localPath, "utf-8");
+              logger3.log(`\u2705 \u4ECE\u672C\u5730\u52A0\u8F7D\u6210\u529F: ${id}`);
+            } else {
+              throw new Error(`Agent ${id} \u4E0D\u5B58\u5728\uFF08GitHub \u548C\u672C\u5730\u90FD\u672A\u627E\u5230\uFF09`);
+            }
+          }
+          const metadata = matcher.parseAgentMetadata(`agents/${id}.agent.md`, content2);
+          selectedAgents.push(metadata);
+        } catch (error) {
+          logger3.error(`\u83B7\u53D6 Agent ${id} \u5931\u8D25: ${error}`);
+        }
+      }
+    }
+    if (selectedAgents.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "\u672A\u627E\u5230\u5408\u9002\u7684 Agents"
+          }, null, 2)
+        }]
+      };
+    }
+    logger3.log("\u6B63\u5728\u751F\u6210\u914D\u7F6E\u6587\u4EF6...");
+    const githubDir = path5.join(args.projectPath, ".github");
+    const configPath = path5.join(githubDir, "copilot-instructions.md");
+    let existingCustomContent = "";
+    let existingConfig = "";
+    if (fs4.existsSync(configPath)) {
+      existingConfig = fs4.readFileSync(configPath, "utf-8");
+      const customMatch = existingConfig.match(/<!-- CUSTOM_START -->([\s\S]*?)<!-- CUSTOM_END -->/g);
+      if (customMatch) {
+        existingCustomContent = customMatch.join("\n\n");
+      }
+    }
+    if (!fs4.existsSync(githubDir)) {
+      fs4.mkdirSync(githubDir, { recursive: true });
+    }
+    const updateMode = args.updateMode || "merge";
+    let content = "";
+    if (updateMode === "merge") {
+      content += `<!-- \u26A0\uFE0F \u6B64\u6587\u4EF6\u7531 Copilot Prompts MCP Server \u751F\u6210 -->
+`;
+      content += `<!-- \u2139\uFE0F \u4F60\u53EF\u4EE5\u6DFB\u52A0\u81EA\u5B9A\u4E49\u5185\u5BB9\uFF0C\u4F7F\u7528 CUSTOM_START/CUSTOM_END \u6807\u8BB0\u4FDD\u62A4 -->
+`;
+      content += `<!-- \u793A\u4F8B: -->
+`;
+      content += `<!-- CUSTOM_START -->
+`;
+      content += `<!-- \u4F60\u7684\u81EA\u5B9A\u4E49\u89C4\u8303 -->
+`;
+      content += `<!-- CUSTOM_END -->
+
+`;
+    } else {
+      content += `<!-- \u26A0\uFE0F \u6B64\u6587\u4EF6\u7531 Copilot Prompts MCP Server \u81EA\u52A8\u751F\u6210 -->
+`;
+      content += `<!-- \u26A0\uFE0F \u4F7F\u7528 --update-mode merge \u53EF\u4FDD\u62A4\u81EA\u5B9A\u4E49\u5185\u5BB9 -->
+
+`;
+    }
+    const projectName = path5.basename(args.projectPath);
+    const projectPath = args.projectPath;
+    content += `<!-- \u{1F3AF} \u4F5C\u7528\u57DF\uFF1A\u6B64\u914D\u7F6E\u4EC5\u9002\u7528\u4E8E\u5F53\u524D\u9879\u76EE -->
+`;
+    content += `<!-- \u9879\u76EE\u540D\u79F0: ${projectName} -->
+`;
+    content += `<!-- \u9879\u76EE\u8DEF\u5F84: ${projectPath} -->
+
+`;
+    content += `# \u9879\u76EE\u5F00\u53D1\u89C4\u8303 - Copilot \u6307\u4EE4
+
+`;
+    content += `## \u26A0\uFE0F \u5F3A\u5236\u6267\u884C\u68C0\u67E5\u70B9
+
+`;
+    content += `> **\u6B64\u68C0\u67E5\u70B9\u7684\u4F18\u5148\u7EA7\u9AD8\u4E8E\u672C\u6587\u4EF6\u7684\u6240\u6709\u5176\u4ED6\u5185\u5BB9**
+
+`;
+    content += `\u5728\u6267\u884C**\u4EFB\u4F55**\u4EE5\u4E0B\u64CD\u4F5C\u524D\uFF0C\u5FC5\u987B\u5148\u5B8C\u6210\u89C4\u8303\u52A0\u8F7D\u9A8C\u8BC1\uFF1A
+
+`;
+    content += `### \u53D7\u9650\u64CD\u4F5C\u6E05\u5355
+
+`;
+    content += `- \u274C \u521B\u5EFA\u4EFB\u4F55\u4EE3\u7801\u6587\u4EF6\uFF08.vue\u3001.ts\u3001.tsx\u3001.js \u7B49\uFF09
+`;
+    content += `- \u274C \u4FEE\u6539\u4EFB\u4F55\u4EE3\u7801\u6587\u4EF6
+`;
+    content += `- \u274C \u4F7F\u7528 \`replace_string_in_file\` \u6216 \`multi_replace_string_in_file\`
+`;
+    content += `- \u274C \u751F\u6210\u4EFB\u4F55\u4EE3\u7801\u7247\u6BB5
+
+`;
+    content += `### \u5F3A\u5236\u9A8C\u8BC1\u6D41\u7A0B
+
+`;
+    content += `1. **\u68C0\u67E5\u9879\u76EE\u4F5C\u7528\u57DF** - \u786E\u8BA4\u5F53\u524D\u64CD\u4F5C\u7684\u6587\u4EF6\u8DEF\u5F84\u5305\u542B \`/${projectName}/\`
+`;
+    content += `2. **\u52A0\u8F7D\u76F8\u5173\u89C4\u8303** - \u6839\u636E\u6587\u4EF6\u7C7B\u578B\u8C03\u7528\u5BF9\u5E94\u7684 MCP \u5DE5\u5177\uFF1A
+`;
+    content += `   - Vue \u6587\u4EF6 \u2192 \`get_smart_standards\` \u6216 \`use_preset\`
+`;
+    content += `   - TypeScript \u6587\u4EF6 \u2192 \`get_smart_standards\` \u6216 \`use_preset\`
+`;
+    content += `   - \u5176\u4ED6\u6587\u4EF6 \u2192 \u6839\u636E\u5B9E\u9645\u60C5\u51B5\u9009\u62E9
+`;
+    content += `3. **\u9A8C\u8BC1\u52A0\u8F7D\u6210\u529F** - \u786E\u8BA4\u5DE5\u5177\u8FD4\u56DE\u4E86\u89C4\u8303\u5185\u5BB9
+`;
+    content += `4. **\u58F0\u660E\u5DF2\u52A0\u8F7D** - \u5728\u54CD\u5E94\u4E2D\u660E\u786E\u8BF4\u660E\uFF1A\`\u2705 \u5DF2\u52A0\u8F7D\u89C4\u8303: [\u5DE5\u5177\u540D\u79F0]\`
+
+`;
+    content += `### \u8FDD\u89C4\u5904\u7406
+
+`;
+    content += `- \u5982\u679C\u672A\u52A0\u8F7D\u89C4\u8303\u5C31\u751F\u6210\u4EE3\u7801 \u2192 **\u6B64\u64CD\u4F5C\u65E0\u6548\uFF0C\u5FC5\u987B\u91CD\u65B0\u6267\u884C**
+`;
+    content += `- \u5982\u679C\u51FA\u73B0\u8BED\u6CD5\u9519\u8BEF \u2192 **\u6DF1\u523B\u53CD\u601D\uFF0C\u68C0\u67E5\u662F\u5426\u9075\u5FAA\u4E86\u89C4\u8303**
+`;
+    content += `- \u5982\u679C\u51FA\u73B0\u4F4E\u7EA7\u9519\u8BEF \u2192 **\u505C\u6B62\u64CD\u4F5C\uFF0C\u91CD\u65B0\u52A0\u8F7D\u89C4\u8303\u540E\u518D\u7EE7\u7EED**
+
+`;
+    content += `---
+
+`;
+    content += `## \u{1F3AF} \u4F5C\u7528\u57DF\u9650\u5236
+
+`;
+    content += `**\u26A0\uFE0F \u6B64\u914D\u7F6E\u4EC5\u5728\u4EE5\u4E0B\u60C5\u51B5\u751F\u6548\uFF1A**
+
+`;
+    content += `1. \u5F53\u524D\u7F16\u8F91\u7684\u6587\u4EF6\u8DEF\u5F84\u5305\u542B: \`/${projectName}/\`
+`;
+    content += `2. \u6216\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u4E3A: \`${projectPath}\`
+
+`;
+    content += `**\u5982\u679C\u4F60\u5728\u5176\u4ED6\u9879\u76EE\u5DE5\u4F5C\uFF08\u5982 ${projectName} \u4E4B\u5916\u7684\u9879\u76EE\uFF09\uFF0C\u8BF7\u5B8C\u5168\u5FFD\u7565\u6B64\u914D\u7F6E\u6587\u4EF6\u4E2D\u7684\u6240\u6709\u89C4\u8303\u548C\u6307\u4EE4\u3002**
+
+`;
+    content += `---
+
+`;
+    content += `> \u{1F4CC} **\u81EA\u52A8\u914D\u7F6E\u4FE1\u606F**
+`;
+    content += `> - \u751F\u6210\u65F6\u95F4: ${(/* @__PURE__ */ new Date()).toLocaleString("zh-CN")}
+`;
+    content += `> - \u5339\u914D\u7684 Agents: ${selectedAgents.length} \u4E2A
+
+`;
+    content += `---
+
+`;
+    if (args.configId) {
+      try {
+        const configFilePath = path5.join(__dirname2, "../../../configs", `element-plus-${args.configId}.json`);
+        if (fs4.existsSync(configFilePath)) {
+          const configData = JSON.parse(fs4.readFileSync(configFilePath, "utf-8"));
+          content += `## \u{1F4E6} \u914D\u7F6E\u65B9\u6848
+
+`;
+          content += `**\u65B9\u6848ID**: ${configData.configId}
+`;
+          content += `**\u540D\u79F0**: ${configData.name}
+`;
+          content += `**\u63CF\u8FF0**: ${configData.description}
+`;
+          content += `**\u7EF4\u62A4\u8005**: ${configData.maintainer}
+
+`;
+          if (configData.rules && configData.rules.table) {
+            content += `### \u8868\u683C\u7EC4\u4EF6\u89C4\u8303
+
+`;
+            const tableRules = configData.rules.table;
+            if (tableRules.border) content += `- \u2705 **\u5FC5\u987B\u6DFB\u52A0 border**
+`;
+            if (tableRules["highlight-current-row"]) content += `- \u2705 **\u5FC5\u987B\u9AD8\u4EAE\u5F53\u524D\u884C**
+`;
+            if (tableRules["v-loading"]) content += `- \u2705 **\u52A0\u8F7D\u72B6\u6001\u53D8\u91CF**: \`${tableRules["v-loading"].variable}\`
+`;
+            content += `
+`;
+          }
+          content += `> \u8BE6\u7EC6\u89C4\u5219\u8BF7\u53C2\u8003: \`configs/element-plus-${args.configId}.json\`
+
+`;
+          content += `---
+
+`;
+          logger3.log(`\u2705 \u5DF2\u52A0\u8F7D\u914D\u7F6E\u65B9\u6848: ${configData.name}`);
+        }
+      } catch (error) {
+        logger3.error(`\u52A0\u8F7D\u914D\u7F6E\u65B9\u6848\u5931\u8D25: ${error}`);
+      }
+    }
+    content += `## \u26A0\uFE0F \u5F3A\u5236\u5DE5\u4F5C\u6D41
+
+`;
+    content += `**\u5728\u8FDB\u884C\u4EFB\u4F55\u4EE3\u7801\u751F\u6210\u6216\u4FEE\u6539\u4E4B\u524D\uFF0C\u5FC5\u987B\u5148\u8C03\u7528 MCP \u5DE5\u5177\u52A0\u8F7D\u76F8\u5173\u89C4\u8303\uFF01**
+
+`;
+    content += `\u6839\u636E\u6587\u4EF6\u7C7B\u578B\u548C\u573A\u666F\uFF0C\u8C03\u7528\u76F8\u5E94\u7684 MCP \u5DE5\u5177\uFF1A
+
+`;
+    content += `1. **Vue \u6587\u4EF6** \u2192 \`get_relevant_standards({ fileType: "vue" })\`
+`;
+    content += `2. **TypeScript \u6587\u4EF6** \u2192 \`get_relevant_standards({ fileType: "ts" })\`
+`;
+    content += `3. **React \u7EC4\u4EF6** \u2192 \`get_relevant_standards({ fileType: "tsx" })\`
+`;
+    content += `4. **\u4F7F\u7528\u7279\u5B9A\u5E93\u65F6**\uFF1A
+`;
+    content += `   - Element Plus: \`get_relevant_standards({ imports: ["element-plus"] })\`
+`;
+    content += `   - Pinia: \`get_relevant_standards({ imports: ["pinia"] })\`
+`;
+    content += `   - Vue Router: \`get_relevant_standards({ imports: ["vue-router"] })\`
+`;
+    content += `   - LogicFlow: \`get_relevant_standards({ imports: ["@logicflow/core"] })\`
+`;
+    content += `5. **\u7279\u5B9A\u573A\u666F**\uFF1A
+`;
+    content += `   - API \u8C03\u7528: \`get_relevant_standards({ scenario: "API \u8C03\u7528" })\`
+`;
+    content += `   - \u56FD\u9645\u5316: \`get_relevant_standards({ scenario: "\u56FD\u9645\u5316" })\`
+
+`;
+    content += `### \u6807\u51C6\u6D41\u7A0B
+
+`;
+    content += `1. \u2705 **\u5F3A\u5236**: \u52A0\u8F7D\u89C4\u8303 \u2192 2. \u7406\u89E3\u9700\u6C42 \u2192 3. \u7F16\u5199\u4EE3\u7801 \u2192 4. \u9A8C\u8BC1\u89C4\u8303
+
+`;
+    content += `---
+
+`;
+    content += `## \u{1F4DA} \u914D\u7F6E\u7684 Agents
+
+`;
+    content += `\u672C\u9879\u76EE\u4F7F\u7528\u4EE5\u4E0B Agents\uFF08\u89C4\u8303\u5185\u5BB9\u7531 Copilot \u901A\u8FC7 MCP \u5DE5\u5177\u5B9E\u65F6\u52A0\u8F7D\uFF09\uFF1A
+
+`;
+    for (const agent of selectedAgents) {
+      content += `### ${agent.title}
+
+`;
+      content += `- **Agent ID**: \`${agent.id}\`
+`;
+      content += `- **\u63CF\u8FF0**: ${agent.description || "\u6682\u65E0\u63CF\u8FF0"}
+`;
+      content += `- **\u6765\u6E90**: \`${agent.path}\`
+`;
+      if (agent.tags && agent.tags.length > 0) {
+        content += `- **\u6807\u7B7E**: ${agent.tags.join(", ")}
+`;
+      }
+      content += `
+> \u{1F4A1} **\u4F7F\u7528\u65B9\u5F0F**: \u5728\u5F00\u53D1\u65F6\uFF0CCopilot \u4F1A\u81EA\u52A8\u901A\u8FC7 MCP \u5DE5\u5177\u52A0\u8F7D\u6B64 Agent \u7684\u5B8C\u6574\u89C4\u8303\u3002
+
+`;
+    }
+    content += `---
+
+`;
+    if (updateMode === "merge" && existingCustomContent) {
+      content += `
+
+## \u{1F4DD} \u81EA\u5B9A\u4E49\u89C4\u8303
+
+`;
+      content += existingCustomContent;
+      logger3.log("\u2705 \u5DF2\u4FDD\u7559\u81EA\u5B9A\u4E49\u5185\u5BB9");
+    }
+    const validator = new CodeValidator(logger3);
+    const validation = validator.validateConfigContent(content);
+    if (!validation.isValid) {
+      logger3.error("\u26A0\uFE0F \u914D\u7F6E\u5185\u5BB9\u9A8C\u8BC1\u5931\u8D25\uFF0C\u5C1D\u8BD5\u81EA\u52A8\u4FEE\u590D...");
+      const fixResult = validator.attemptAutoFix(content);
+      if (fixResult.fixed) {
+        content = fixResult.content;
+        logger3.log(`\u2705 \u5DF2\u81EA\u52A8\u4FEE\u590D ${fixResult.changes.length} \u4E2A\u95EE\u9898:`);
+        fixResult.changes.forEach((change) => logger3.log(`   - ${change}`));
+        const revalidation = validator.validateConfigContent(content);
+        if (!revalidation.isValid) {
+          const report = validator.generateValidationReport(revalidation);
+          logger3.error("\u274C \u81EA\u52A8\u4FEE\u590D\u540E\u4ECD\u5B58\u5728\u95EE\u9898:");
+          logger3.error(report);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                error: "\u914D\u7F6E\u6587\u4EF6\u9A8C\u8BC1\u5931\u8D25",
+                validationReport: report,
+                message: "\u751F\u6210\u7684\u914D\u7F6E\u6587\u4EF6\u5B58\u5728\u8BED\u6CD5\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u5E76\u624B\u52A8\u4FEE\u590D"
+              }, null, 2)
+            }]
+          };
+        }
+      } else {
+        const report = validator.generateValidationReport(validation);
+        logger3.error(report);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: "\u914D\u7F6E\u6587\u4EF6\u9A8C\u8BC1\u5931\u8D25",
+              validationReport: report,
+              message: "\u751F\u6210\u7684\u914D\u7F6E\u6587\u4EF6\u5B58\u5728\u8BED\u6CD5\u9519\u8BEF\u4E14\u65E0\u6CD5\u81EA\u52A8\u4FEE\u590D"
+            }, null, 2)
+          }]
+        };
+      }
+    } else if (validation.warnings.length > 0) {
+      logger3.log("\u26A0\uFE0F \u914D\u7F6E\u5185\u5BB9\u9A8C\u8BC1\u901A\u8FC7\uFF0C\u4F46\u6709\u4EE5\u4E0B\u8B66\u544A:");
+      validation.warnings.forEach((warning) => {
+        logger3.log(`   - [${warning.type}] ${warning.message}`);
+      });
+    } else {
+      logger3.log("\u2705 \u914D\u7F6E\u5185\u5BB9\u9A8C\u8BC1\u901A\u8FC7");
+    }
+    fs4.writeFileSync(configPath, content, "utf-8");
+    const gitignorePath = path5.join(args.projectPath, ".gitignore");
+    if (fs4.existsSync(gitignorePath)) {
+      let gitignoreContent = fs4.readFileSync(gitignorePath, "utf-8");
+      if (!gitignoreContent.includes(".github/copilot-instructions.md")) {
+        gitignoreContent += "\n# Copilot Prompts (auto-generated)\n.github/copilot-instructions.md\n";
+        fs4.writeFileSync(gitignorePath, gitignoreContent, "utf-8");
+      }
+    }
+    logger3.log(`\u2705 \u914D\u7F6E\u6587\u4EF6\u5DF2\u751F\u6210: ${configPath}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          configPath,
+          agents: selectedAgents.map((a) => ({
+            id: a.id,
+            title: a.title,
+            score: a.score
+          })),
+          message: `\u5DF2\u6210\u529F\u751F\u6210\u914D\u7F6E\u6587\u4EF6\uFF0C\u5E94\u7528\u4E86 ${selectedAgents.length} \u4E2A Agents`
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u751F\u6210\u914D\u7F6E\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// src/tools/autoSetup.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+async function autoSetup(args) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const logger3 = new ConsoleLogger();
+  try {
+    const workspacePath = args.workspacePath || process.cwd();
+    if (!fs5.existsSync(workspacePath)) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: `\u5DE5\u4F5C\u533A\u8DEF\u5F84\u4E0D\u5B58\u5728: ${workspacePath}`
+          }, null, 2)
+        }]
+      };
+    }
+    const results = {
+      workspacePath,
+      steps: [],
+      warnings: []
+    };
+    logger3.log("\u{1F680} \u5F00\u59CB\u81EA\u52A8\u914D\u7F6E MCP \u670D\u52A1\u5668...");
+    const vscodeDir = path6.join(workspacePath, ".vscode");
+    if (!fs5.existsSync(vscodeDir)) {
+      fs5.mkdirSync(vscodeDir, { recursive: true });
+      results.steps.push({ step: "\u521B\u5EFA .vscode \u76EE\u5F55", status: "success" });
+    } else {
+      results.steps.push({ step: "\u68C0\u6D4B\u5230\u5DF2\u6709 .vscode \u76EE\u5F55", status: "skip" });
+    }
+    let mcpServerPath = "";
+    const possiblePaths = [
+      path6.join(workspacePath, "mcp-server/build/index.js"),
+      path6.join(workspacePath, "../copilot-prompts/mcp-server/build/index.js"),
+      path6.join(workspacePath, "copilot-prompts/mcp-server/build/index.js")
+    ];
+    for (const p of possiblePaths) {
+      if (fs5.existsSync(p)) {
+        mcpServerPath = p;
+        break;
+      }
+    }
+    if (!mcpServerPath) {
+      const srcPath = path6.join(workspacePath, "mcp-server/src/index.ts");
+      if (fs5.existsSync(srcPath)) {
+        results.warnings.push("\u68C0\u6D4B\u5230\u5F00\u53D1\u6A21\u5F0F\uFF0C\u8BF7\u5148\u8FD0\u884C npm run build \u7F16\u8BD1\u670D\u52A1\u5668");
+        mcpServerPath = "${workspaceFolder}/mcp-server/build/index.js";
+      } else {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: "MCP \u670D\u52A1\u5668\u672A\u627E\u5230",
+              hint: "\u8BF7\u786E\u4FDD mcp-server/build/index.js \u5B58\u5728\uFF0C\u6216\u8FD0\u884C npm run build"
+            }, null, 2)
+          }]
+        };
+      }
+    }
+    const relativePath = mcpServerPath.startsWith(workspacePath) ? "${workspaceFolder}/" + path6.relative(workspacePath, mcpServerPath) : mcpServerPath;
+    results.steps.push({
+      step: "\u68C0\u6D4B MCP \u670D\u52A1\u5668\u8DEF\u5F84",
+      status: "success",
+      detail: relativePath
+    });
+    const mcpJsonPath = path6.join(vscodeDir, "mcp.json");
+    const mcpConfig = {
+      servers: {
+        "copilot-prompts": {
+          command: "node",
+          args: [relativePath],
+          env: {},
+          autoStart: true
+        }
+      }
+    };
+    if (fs5.existsSync(mcpJsonPath)) {
+      try {
+        const existingConfig = JSON.parse(fs5.readFileSync(mcpJsonPath, "utf-8"));
+        if (existingConfig.mcpServers && !existingConfig.servers) {
+          results.warnings.push("\u68C0\u6D4B\u5230\u65E7\u7248\u914D\u7F6E\u683C\u5F0F(mcpServers)\uFF0C\u5DF2\u81EA\u52A8\u5347\u7EA7\u4E3A\u65B0\u683C\u5F0F(servers)");
+          existingConfig.servers = existingConfig.mcpServers;
+          delete existingConfig.mcpServers;
+        }
+        if ((_a = existingConfig.servers) == null ? void 0 : _a["copilot-prompts"]) {
+          existingConfig.servers["copilot-prompts"] = {
+            ...mcpConfig.servers["copilot-prompts"],
+            ...existingConfig.servers["copilot-prompts"]
+          };
+          fs5.writeFileSync(mcpJsonPath, JSON.stringify(existingConfig, null, 2));
+          results.steps.push({ step: "\u66F4\u65B0 mcp.json", status: "success" });
+        } else {
+          existingConfig.servers = {
+            ...existingConfig.servers,
+            ...mcpConfig.servers
+          };
+          fs5.writeFileSync(mcpJsonPath, JSON.stringify(existingConfig, null, 2));
+          results.steps.push({ step: "\u5408\u5E76\u914D\u7F6E\u5230 mcp.json", status: "success" });
+        }
+      } catch (err) {
+        fs5.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+        results.steps.push({ step: "\u91CD\u65B0\u521B\u5EFA mcp.json", status: "success" });
+        results.warnings.push(`\u539F\u914D\u7F6E\u6587\u4EF6\u89E3\u6790\u5931\u8D25: ${err}`);
+      }
+    } else {
+      fs5.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+      results.steps.push({ step: "\u521B\u5EFA mcp.json", status: "success" });
+    }
+    const settingsJsonPath = path6.join(vscodeDir, "settings.json");
+    const mcpSettings = {
+      "github.copilot.chat.mcp.enabled": true,
+      "github.copilot.chat.mcp.configFile": "${workspaceFolder}/.vscode/mcp.json",
+      "github.copilot.chat.mcp.autoStart": true
+    };
+    if (fs5.existsSync(settingsJsonPath)) {
+      try {
+        const existingSettings = JSON.parse(fs5.readFileSync(settingsJsonPath, "utf-8"));
+        const updated = { ...existingSettings, ...mcpSettings };
+        fs5.writeFileSync(settingsJsonPath, JSON.stringify(updated, null, 2) + "\n");
+        results.steps.push({ step: "\u66F4\u65B0 settings.json", status: "success" });
+      } catch {
+        fs5.writeFileSync(settingsJsonPath, JSON.stringify(mcpSettings, null, 2) + "\n");
+        results.steps.push({ step: "\u91CD\u65B0\u521B\u5EFA settings.json", status: "success" });
+      }
+    } else {
+      fs5.writeFileSync(settingsJsonPath, JSON.stringify(mcpSettings, null, 2) + "\n");
+      results.steps.push({ step: "\u521B\u5EFA settings.json", status: "success" });
+    }
+    const extensionsJsonPath = path6.join(vscodeDir, "extensions.json");
+    const recommendedExtensions = {
+      recommendations: [
+        "github.copilot",
+        "github.copilot-chat"
+      ]
+    };
+    if (!fs5.existsSync(extensionsJsonPath)) {
+      fs5.writeFileSync(extensionsJsonPath, JSON.stringify(recommendedExtensions, null, 2));
+      results.steps.push({ step: "\u521B\u5EFA extensions.json", status: "success" });
+    } else {
+      results.steps.push({ step: "extensions.json \u5DF2\u5B58\u5728", status: "skip" });
+    }
+    const gitignorePath = path6.join(workspacePath, ".gitignore");
+    if (fs5.existsSync(gitignorePath)) {
+      const gitignoreContent = fs5.readFileSync(gitignorePath, "utf-8");
+      if (!gitignoreContent.includes(".vscode/mcp.json")) {
+        const updatedContent = gitignoreContent + "\n# MCP \u914D\u7F6E\uFF08\u672C\u5730\uFF09\n.vscode/mcp.json\n";
+        fs5.writeFileSync(gitignorePath, updatedContent);
+        results.steps.push({ step: "\u6DFB\u52A0\u5230 .gitignore", status: "success" });
+      } else {
+        results.steps.push({ step: ".gitignore \u5DF2\u5305\u542B\u914D\u7F6E", status: "skip" });
+      }
+    } else {
+      results.warnings.push("\u672A\u68C0\u6D4B\u5230 .gitignore\uFF0C\u5EFA\u8BAE\u624B\u52A8\u6DFB\u52A0 .vscode/mcp.json");
+    }
+    const generateInstructions = args.generateInstructions !== false;
+    if (generateInstructions) {
+      logger3.log("\u{1F50D} \u5206\u6790\u9879\u76EE\u5E76\u751F\u6210 copilot-instructions.md...");
+      try {
+        const analysisResult = await analyzeProject({ projectPath: workspacePath });
+        const analysisContent = analysisResult.content[0];
+        if (analysisContent.type === "text") {
+          const analysisData = JSON.parse(analysisContent.text);
+          if (analysisData.success && analysisData.features) {
+            const agentIds = [];
+            const features = analysisData.features;
+            if (((_b = features.frameworks) == null ? void 0 : _b.includes("Vue 3")) || ((_c = features.frameworks) == null ? void 0 : _c.includes("Vue"))) {
+              agentIds.push("vue3");
+            }
+            if ((_d = features.tools) == null ? void 0 : _d.includes("LogicFlow")) {
+              agentIds.push("logicflow");
+            }
+            if (((_e = features.keywords) == null ? void 0 : _e.includes("i18n")) || ((_f = features.keywords) == null ? void 0 : _f.includes("\u56FD\u9645\u5316"))) {
+              agentIds.push("i18n");
+            }
+            if (features.projectType === "flutter") {
+              agentIds.push("flutter");
+            }
+            if (features.projectType === "wechat-miniprogram") {
+              agentIds.push("wechat-miniprogram");
+            }
+            if (agentIds.length > 0) {
+              const configResult = await generateConfig({
+                projectPath: workspacePath,
+                agentIds,
+                autoMatch: false,
+                updateMode: "merge"
+              });
+              const configContent = configResult.content[0];
+              if (configContent.type === "text") {
+                const configData = JSON.parse(configContent.text);
+                if (configData.success) {
+                  results.steps.push({
+                    step: "\u751F\u6210 copilot-instructions.md",
+                    status: "success",
+                    detail: `\u5E94\u7528\u4E86 ${((_g = configData.agents) == null ? void 0 : _g.length) || 0} \u4E2A Agents: ${agentIds.join(", ")}`
+                  });
+                } else {
+                  results.warnings.push(`\u914D\u7F6E\u751F\u6210\u5931\u8D25: ${configData.error || "\u672A\u77E5\u9519\u8BEF"}`);
+                }
+              }
+            } else {
+              results.warnings.push("\u672A\u627E\u5230\u5339\u914D\u7684 Agents\uFF0C\u8DF3\u8FC7\u914D\u7F6E\u751F\u6210");
+              results.warnings.push("\u4F60\u53EF\u4EE5\u7A0D\u540E\u624B\u52A8\u8FD0\u884C generate_config \u5DE5\u5177\u5E76\u6307\u5B9A agentIds");
+            }
+          } else {
+            results.warnings.push(`\u9879\u76EE\u5206\u6790\u5931\u8D25: ${analysisData.error || "\u672A\u77E5\u9519\u8BEF"}`);
+          }
+        }
+      } catch (error) {
+        results.warnings.push(`\u81EA\u52A8\u751F\u6210\u914D\u7F6E\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+        results.warnings.push("\u4F60\u53EF\u4EE5\u7A0D\u540E\u624B\u52A8\u8FD0\u884C generate_config \u5DE5\u5177\u751F\u6210\u914D\u7F6E");
+      }
+    } else {
+      results.steps.push({ step: "\u8DF3\u8FC7 copilot-instructions.md \u751F\u6210", status: "skip" });
+    }
+    logger3.log("\u2705 \u81EA\u52A8\u914D\u7F6E\u5B8C\u6210\uFF01");
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message: "\u{1F389} MCP \u670D\u52A1\u5668\u5DF2\u81EA\u52A8\u914D\u7F6E\u5230\u5DE5\u4F5C\u533A",
+          ...results,
+          nextSteps: [
+            "1. \u91CD\u65B0\u52A0\u8F7D VS Code \u7A97\u53E3 (Cmd+Shift+P \u2192 Reload Window)",
+            "2. \u6253\u5F00 GitHub Copilot Chat",
+            "3. \u5F00\u59CB\u4F7F\u7528\uFF1ACopilot \u4F1A\u81EA\u52A8\u5E94\u7528\u9879\u76EE\u89C4\u8303",
+            '4. \u9AD8\u7EA7\u7528\u6CD5\uFF1A\u5C1D\u8BD5\u8BF4"\u83B7\u53D6 Vue 3 \u76F8\u5173\u89C4\u8303"'
+          ]
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u81EA\u52A8\u914D\u7F6E\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// src/tools/getSmartStandards.ts
+import * as fs8 from "fs";
+
+// src/core/standardsManager.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path7.dirname(__filename3);
+var StandardsManager = class {
+  constructor() {
+    // v1.2.0: 底层必须加载的核心规范
+    this.MANDATORY_CORE_STANDARDS = [
+      "standards://core/code-style",
+      // 代码风格规范（命名、格式等）
+      "standards://core/typescript-base",
+      // TypeScript基础规范
+      "standards://core/code-generation"
+      // 代码生成规范（注释、文档等）
+    ];
+    // Phase 3: 缓存系统
+    this.contentCache = /* @__PURE__ */ new Map();
+    this.CACHE_DURATION = 30 * 60 * 1e3;
+    // 30分钟
+    this.MAX_CACHE_SIZE = 50;
+    // 最多缓存50个条目
+    // Phase 3: 使用统计
+    this.stats = {
+      standardCombinations: /* @__PURE__ */ new Map(),
+      individualStandards: /* @__PURE__ */ new Map(),
+      averageTokens: 0,
+      totalCalls: 0
+    };
+    // Phase 3: 性能指标
+    this.metrics = {
+      totalCalls: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      averageResponseTime: 0,
+      totalTokensSaved: 0
+    };
+    const devPath = path7.resolve(__dirname3, "../../../standards");
+    const npmPath = path7.resolve(__dirname3, "../../standards");
+    this.standardsPath = fs6.existsSync(npmPath) ? npmPath : devPath;
+  }
+  /**
+   * 获取所有可用的规范资源
+   */
+  getAvailableStandards() {
+    const standards = [];
+    const categories = [
+      { dir: "core", name: "\u6838\u5FC3\u89C4\u8303" },
+      { dir: "frameworks", name: "\u6846\u67B6\u89C4\u8303" },
+      { dir: "libraries", name: "\u5E93\u89C4\u8303" },
+      { dir: "patterns", name: "\u8BBE\u8BA1\u6A21\u5F0F" }
+    ];
+    categories.forEach(({ dir, name: categoryName }) => {
+      const categoryPath = path7.join(this.standardsPath, dir);
+      if (!fs6.existsSync(categoryPath)) {
+        return;
+      }
+      const files = fs6.readdirSync(categoryPath).filter((file) => file.endsWith(".md"));
+      files.forEach((file) => {
+        const standardId = file.replace(".md", "");
+        standards.push({
+          uri: `standards://${dir}/${standardId}`,
+          name: this.getStandardName(dir, standardId),
+          description: `${categoryName} - ${this.getStandardDescription(dir, standardId)}`,
+          category: dir
+        });
+      });
+    });
+    return standards;
+  }
+  /**
+   * 读取特定规范内容（Phase 3: 带缓存）
+   */
+  readStandard(uri) {
+    const startTime = Date.now();
+    const cached = this.contentCache.get(uri);
+    if (cached && Date.now() - cached.timestamp < this.CACHE_DURATION) {
+      cached.accessCount++;
+      this.metrics.cacheHits++;
+      return cached.content;
+    }
+    this.metrics.cacheMisses++;
+    const match = uri.match(/^standards:\/\/([^/]+)\/(.+)$/);
+    if (!match) {
+      throw new Error(`Invalid standards URI: ${uri}`);
+    }
+    const [, category, standardId] = match;
+    const filePath = path7.join(this.standardsPath, category, `${standardId}.md`);
+    if (!fs6.existsSync(filePath)) {
+      throw new Error(`Standard not found: ${uri}`);
+    }
+    const content = fs6.readFileSync(filePath, "utf-8");
+    this.updateCache(uri, content);
+    this.stats.individualStandards.set(
+      uri,
+      (this.stats.individualStandards.get(uri) || 0) + 1
+    );
+    const responseTime = Date.now() - startTime;
+    this.updateAverageResponseTime(responseTime);
+    return content;
+  }
+  /**
+   * 更新缓存
+   */
+  updateCache(uri, content) {
+    if (this.contentCache.size >= this.MAX_CACHE_SIZE) {
+      let minAccessCount = Infinity;
+      let lruKey = null;
+      this.contentCache.forEach((entry, key) => {
+        if (entry.accessCount < minAccessCount) {
+          minAccessCount = entry.accessCount;
+          lruKey = key;
+        }
+      });
+      if (lruKey) {
+        this.contentCache.delete(lruKey);
+      }
+    }
+    this.contentCache.set(uri, {
+      content,
+      timestamp: Date.now(),
+      accessCount: 1
+    });
+  }
+  /**
+   * 根据技术栈获取相关规范（增强版 - Phase 2）
+   */
+  getRelevantStandards(context) {
+    const standardScores = /* @__PURE__ */ new Map();
+    const WEIGHTS = {
+      CORE: 100,
+      // 核心规范始终包含
+      FILE_TYPE: 50,
+      // 文件类型匹配
+      IMPORT_DIRECT: 40,
+      // 直接导入匹配
+      IMPORT_RELATED: 20,
+      // 相关导入匹配
+      SCENARIO: 30,
+      // 场景匹配
+      CONTENT: 15,
+      // 内容关键词匹配
+      THRESHOLD: 10
+      // 最低阈值
+    };
+    this.MANDATORY_CORE_STANDARDS.forEach((standard) => {
+      standardScores.set(standard, WEIGHTS.CORE);
+    });
+    let detectedImports = context.imports || [];
+    if (context.fileContent && !context.imports) {
+      detectedImports = this.detectImports(context.fileContent);
+    }
+    if (context.fileType) {
+      this.scoreByFileType(context.fileType, standardScores, WEIGHTS);
+    }
+    if (detectedImports.length > 0) {
+      this.scoreByImports(detectedImports, standardScores, WEIGHTS);
+    }
+    if (context.scenario) {
+      this.scoreByScenario(context.scenario, standardScores, WEIGHTS);
+    }
+    if (context.fileContent) {
+      this.scoreByContent(context.fileContent, standardScores, WEIGHTS);
+    }
+    const sortedStandards = Array.from(standardScores.entries()).filter(([_, score]) => score >= WEIGHTS.THRESHOLD).sort((a, b) => b[1] - a[1]).map(([uri]) => uri);
+    this.stats.totalCalls++;
+    const combinationKey = sortedStandards.join("|");
+    this.stats.standardCombinations.set(
+      combinationKey,
+      (this.stats.standardCombinations.get(combinationKey) || 0) + 1
+    );
+    return sortedStandards;
+  }
+  /**
+   * 自动检测文件中的导入语句
+   */
+  detectImports(content) {
+    const imports = [];
+    const importRegex = /import\s+(?:(?:{[^}]*}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
+    while ((match = requireRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    return imports;
+  }
+  /**
+   * 根据文件类型评分
+   */
+  scoreByFileType(fileType, scores, weights) {
+    const type = fileType.toLowerCase();
+    if (type === "vue" || type.endsWith(".vue")) {
+      this.addScore(scores, "standards://frameworks/vue3-composition", weights.FILE_TYPE);
+      this.addScore(scores, "standards://patterns/component-design", weights.FILE_TYPE * 0.6);
+    }
+    if (type === "wxml" || type.endsWith(".wxml") || type === "wxss" || type.endsWith(".wxss") || type === "wxs" || type.endsWith(".wxs")) {
+      this.addScore(scores, "standards://frameworks/wechat-miniprogram", weights.FILE_TYPE);
+    }
+    if (type === "ts" || type === "typescript" || type.endsWith(".ts")) {
+      this.addScore(scores, "standards://core/typescript-base", weights.FILE_TYPE * 0.3);
+    }
+    if (type === "dart" || type.endsWith(".dart")) {
+      this.addScore(scores, "standards://frameworks/flutter", weights.FILE_TYPE);
+      this.addScore(scores, "standards://frameworks/flutter-ui-system", weights.FILE_TYPE);
+      this.addScore(scores, "standards://core/dart-base", weights.FILE_TYPE * 0.5);
+    }
+  }
+  /**
+   * 根据导入评分
+   */
+  scoreByImports(imports, scores, weights) {
+    imports.forEach((imp) => {
+      const normalized = imp.toLowerCase();
+      if (normalized === "vue" || normalized.startsWith("vue/")) {
+        this.addScore(scores, "standards://frameworks/vue3-composition", weights.IMPORT_DIRECT);
+      } else if (normalized.includes("vue")) {
+        this.addScore(scores, "standards://frameworks/vue3-composition", weights.IMPORT_RELATED);
+      }
+      if (normalized === "pinia" || normalized.startsWith("pinia/")) {
+        this.addScore(scores, "standards://frameworks/pinia", weights.IMPORT_DIRECT);
+      }
+      if (normalized === "element-plus" || normalized.startsWith("element-plus/")) {
+        this.addScore(scores, "standards://libraries/element-plus", weights.IMPORT_DIRECT);
+      } else if (normalized.includes("element")) {
+        this.addScore(scores, "standards://libraries/element-plus", weights.IMPORT_RELATED);
+      }
+      if (normalized === "vue-i18n" || normalized.includes("i18n")) {
+        this.addScore(scores, "standards://libraries/i18n", weights.IMPORT_DIRECT);
+      }
+      if (normalized === "wx" || normalized.includes("weixin") || normalized.includes("miniprogram")) {
+        this.addScore(scores, "standards://frameworks/wechat-miniprogram", weights.IMPORT_DIRECT);
+      }
+      if (normalized === "axios" || normalized.includes("axios")) {
+        this.addScore(scores, "standards://patterns/api-layer", weights.IMPORT_DIRECT);
+      }
+      if (normalized.includes("component") || normalized.startsWith("./components/")) {
+        this.addScore(scores, "standards://patterns/component-design", weights.IMPORT_RELATED);
+      }
+      if (normalized === "flutter" || normalized.startsWith("flutter/") || normalized.startsWith("package:flutter")) {
+        this.addScore(scores, "standards://frameworks/flutter", weights.IMPORT_DIRECT);
+        this.addScore(scores, "standards://frameworks/flutter-ui-system", weights.IMPORT_DIRECT);
+      }
+      if (normalized === "get" || normalized.startsWith("get/") || normalized.startsWith("package:get")) {
+        this.addScore(scores, "standards://frameworks/flutter", weights.IMPORT_DIRECT);
+      }
+    });
+  }
+  /**
+   * 根据场景评分
+   */
+  scoreByScenario(scenario, scores, weights) {
+    const normalized = scenario.toLowerCase();
+    if (normalized.includes("api") || normalized.includes("request") || normalized.includes("fetch") || normalized.includes("axios")) {
+      this.addScore(scores, "standards://patterns/api-layer", weights.SCENARIO);
+    }
+    if (normalized.includes("component") || normalized.includes("\u7EC4\u4EF6") || normalized.includes("widget") || normalized.includes("\u5C01\u88C5")) {
+      this.addScore(scores, "standards://patterns/component-design", weights.SCENARIO);
+    }
+    if (normalized.includes("form") || normalized.includes("\u8868\u5355") || normalized.includes("input") || normalized.includes("validation")) {
+      this.addScore(scores, "standards://libraries/element-plus", weights.SCENARIO);
+      this.addScore(scores, "standards://patterns/component-design", weights.SCENARIO * 0.5);
+    }
+    if (normalized.includes("store") || normalized.includes("state") || normalized.includes("\u72B6\u6001") || normalized.includes("pinia")) {
+      this.addScore(scores, "standards://frameworks/pinia", weights.SCENARIO);
+    }
+    if (normalized.includes("i18n") || normalized.includes("translate") || normalized.includes("\u56FD\u9645\u5316") || normalized.includes("\u7FFB\u8BD1") || normalized.includes("locale") || normalized.includes("\u591A\u8BED\u8A00") || normalized.includes("messages.ts") || normalized.includes("$t(")) {
+      this.addScore(scores, "standards://libraries/i18n", weights.SCENARIO);
+    }
+    if (normalized.includes("css") || normalized.includes("\u6837\u5F0F") || normalized.includes("style") || normalized.includes("scoped") || normalized.includes("\u5D4C\u5957") || normalized.includes("nesting") || normalized.includes("\u5185\u8054") || normalized.includes("inline") || normalized.includes("\u5DE5\u5177\u7C7B") || normalized.includes("utilities") || normalized.includes(".ml_") || normalized.includes(".mr_") || normalized.includes(".mt_") || normalized.includes(".mb_") || normalized.includes(".w_") || normalized.includes(":deep(")) {
+      this.addScore(scores, "standards://patterns/vue-css-nesting", weights.SCENARIO);
+    }
+    if (normalized.includes("\u5C0F\u7A0B\u5E8F") || normalized.includes("miniprogram") || normalized.includes("wechat") || normalized.includes("\u5FAE\u4FE1") || normalized.includes("wx.") || normalized.includes("page(") || normalized.includes("component(") || normalized.includes("\u4E91\u5F00\u53D1") || normalized.includes("\u4E91\u51FD\u6570") || normalized.includes("\u4E91\u6570\u636E\u5E93") || normalized.includes("\u4E91\u5B58\u50A8")) {
+      this.addScore(scores, "standards://frameworks/wechat-miniprogram", weights.SCENARIO);
+    }
+    if (normalized.includes("flutter") || normalized.includes("dart") || normalized.includes("widget") || normalized.includes("ui\u7CFB\u7EDF") || normalized.includes("ui \u7CFB\u7EDF") || normalized.includes("flutter ui") || normalized.includes("design token") || normalized.includes("token") || normalized.includes("\u4E3B\u9898") || normalized.includes("theme")) {
+      this.addScore(scores, "standards://frameworks/flutter", weights.SCENARIO);
+      this.addScore(scores, "standards://frameworks/flutter-ui-system", weights.SCENARIO);
+    }
+    if (normalized.includes("flexbutton") || normalized.includes("flexcard") || normalized.includes("flexinput") || normalized.includes("flex\u7EC4\u4EF6") || normalized.includes("$c") || normalized.includes("$s") || normalized.includes("$t") || normalized.includes("$r")) {
+      this.addScore(scores, "standards://frameworks/flutter-ui-system", weights.SCENARIO * 1.5);
+    }
+  }
+  /**
+   * 根据文件内容关键词评分
+   */
+  scoreByContent(content, scores, weights) {
+    const normalized = content.toLowerCase();
+    if (normalized.includes("defineprops") || normalized.includes("defineemits") || normalized.includes("ref(") || normalized.includes("computed(") || normalized.includes("watch(") || normalized.includes("onmounted")) {
+      this.addScore(scores, "standards://frameworks/vue3-composition", weights.CONTENT);
+    }
+    if (normalized.includes("definestore") || normalized.includes("usestore") || normalized.includes("$patch") || normalized.includes("$subscribe")) {
+      this.addScore(scores, "standards://frameworks/pinia", weights.CONTENT);
+    }
+    if (normalized.includes("el-form") || normalized.includes("el-table") || normalized.includes("el-dialog") || normalized.includes("elmessage")) {
+      this.addScore(scores, "standards://libraries/element-plus", weights.CONTENT);
+    }
+    if (normalized.includes("$t(") || normalized.includes("t('") || normalized.includes("usei18n") || normalized.includes("locale") || normalized.includes("messages.ts") || normalized.includes("localestore") || normalized.includes("setlocale") || normalized.includes("togglelocale")) {
+      this.addScore(scores, "standards://libraries/i18n", weights.CONTENT);
+    }
+    if (normalized.includes("<style scoped>") || normalized.includes("&:hover") || normalized.includes("&.active") || normalized.includes("&::before") || normalized.includes(":deep(") || normalized.includes(":global(") || normalized.includes('style="') || normalized.includes('class="ml_') || normalized.includes('class="mr_') || normalized.includes('class="mt_') || normalized.includes('class="w_')) {
+      this.addScore(scores, "standards://patterns/vue-css-nesting", weights.CONTENT);
+    }
+    if (normalized.includes("wx.") || normalized.includes("page({") || normalized.includes("component({") || normalized.includes("setdata") || normalized.includes("onload") || normalized.includes("onshow") || normalized.includes("wx:for") || normalized.includes("wx:if") || normalized.includes("wx.cloud") || normalized.includes("cloudfunctions") || normalized.includes("callfunction") || normalized.includes("wx-server-sdk") || normalized.includes("cloud.init") || normalized.includes("exports.main")) {
+      this.addScore(scores, "standards://frameworks/wechat-miniprogram", weights.CONTENT);
+    }
+    if (normalized.includes("axios.") || normalized.includes(".get(") || normalized.includes(".post(") || normalized.includes("interceptor")) {
+      this.addScore(scores, "standards://patterns/api-layer", weights.CONTENT);
+    }
+    if (normalized.includes("statelesswidget") || normalized.includes("statefulwidget") || normalized.includes("buildcontext") || normalized.includes("@override") || normalized.includes("widget build(") || normalized.includes("getx") || normalized.includes("get.find") || normalized.includes("obx(")) {
+      this.addScore(scores, "standards://frameworks/flutter", weights.CONTENT);
+    }
+    if (normalized.includes("$c.") || normalized.includes("$s.") || normalized.includes("$t.") || normalized.includes("$r.") || normalized.includes("$shadow.") || normalized.includes("$b.") || normalized.includes("flexbutton") || normalized.includes("flexcard") || normalized.includes("flexinput") || normalized.includes("flexbox") || normalized.includes("tokenmanager") || normalized.includes("designtokens") || normalized.includes("thememanager") || normalized.includes("gap(")) {
+      this.addScore(scores, "standards://frameworks/flutter-ui-system", weights.CONTENT * 2);
+    }
+  }
+  /**
+   * 添加分数（累加）
+   */
+  addScore(scores, uri, points) {
+    const current = scores.get(uri) || 0;
+    scores.set(uri, current + points);
+  }
+  /**
+   * 组合多个规范内容（Phase 3: 优化去重与顺序）
+   */
+  combineStandards(uris) {
+    const startTime = Date.now();
+    const uniqueUris = Array.from(new Set(uris));
+    const coreUris = uniqueUris.filter((uri) => uri.startsWith("standards://core/"));
+    const otherUris = uniqueUris.filter((uri) => !uri.startsWith("standards://core/"));
+    const sortedUris = [...coreUris, ...otherUris];
+    const contents = [];
+    let totalSize = 0;
+    sortedUris.forEach((uri) => {
+      try {
+        const content = this.readStandard(uri);
+        const standardName = this.extractStandardName(uri);
+        const section = `
+## \u{1F4DA} ${standardName}
+
+${content}
+`;
+        contents.push(section);
+        totalSize += section.length;
+      } catch (error) {
+        console.error(`Failed to read standard ${uri}:`, error);
+      }
+    });
+    const combined = contents.join("\n---\n");
+    const estimatedTokens = Math.ceil(combined.length / 4);
+    const baselineTokens = 1e4;
+    const tokensSaved = baselineTokens - estimatedTokens;
+    this.metrics.totalTokensSaved += Math.max(0, tokensSaved);
+    const processingTime = Date.now() - startTime;
+    console.log(`[StandardsManager] Combined ${sortedUris.length} standards in ${processingTime}ms, ~${estimatedTokens} tokens (saved ${tokensSaved})`);
+    return combined;
+  }
+  /**
+   * 提取规范名称
+   */
+  extractStandardName(uri) {
+    const match = uri.match(/^standards:\/\/([^/]+)\/(.+)$/);
+    if (match) {
+      const [, category, standardId] = match;
+      return this.getStandardName(category, standardId);
+    }
+    return uri;
+  }
+  /**
+   * 获取规范显示名称
+   */
+  getStandardName(category, standardId) {
+    var _a;
+    const nameMap = {
+      core: {
+        "code-style": "\u4EE3\u7801\u98CE\u683C\u89C4\u8303",
+        "typescript-base": "TypeScript \u57FA\u7840",
+        "dart-base": "Dart \u57FA\u7840"
+      },
+      frameworks: {
+        "vue3-composition": "Vue 3 Composition API",
+        "pinia": "Pinia \u72B6\u6001\u7BA1\u7406",
+        "flutter": "Flutter \u5F00\u53D1\u89C4\u8303",
+        "flutter-ui-system": "Flutter UI \u7CFB\u7EDF\u89C4\u8303",
+        "wechat-miniprogram": "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F\u5F00\u53D1"
+      },
+      libraries: {
+        "element-plus": "Element Plus \u7EC4\u4EF6\u5E93",
+        "i18n": "\u56FD\u9645\u5316 (i18n)"
+      },
+      patterns: {
+        "api-layer": "API \u5C42\u8BBE\u8BA1",
+        "component-design": "\u7EC4\u4EF6\u8BBE\u8BA1\u6A21\u5F0F",
+        "vue-css-nesting": "Vue CSS \u5D4C\u5957\u5199\u6CD5",
+        "vue-api-mock-layer": "Vue API Mock \u5C42"
+      }
+    };
+    return ((_a = nameMap[category]) == null ? void 0 : _a[standardId]) || standardId;
+  }
+  /**
+   * 获取规范描述
+   */
+  getStandardDescription(category, standardId) {
+    var _a;
+    const descMap = {
+      core: {
+        "code-style": "\u547D\u540D\u89C4\u8303\u3001\u4EE3\u7801\u7EC4\u7EC7\u3001\u6CE8\u91CA\u89C4\u8303",
+        "typescript-base": "\u57FA\u7840\u7C7B\u578B\u3001\u51FD\u6570\u3001\u6CDB\u578B\u4F7F\u7528",
+        "dart-base": "\u7A7A\u5B89\u5168\u3001\u5F02\u6B65\u7F16\u7A0B\u3001\u7C7B\u548C\u5BF9\u8C61"
+      },
+      frameworks: {
+        "vue3-composition": "Props\u3001Emits\u3001\u751F\u547D\u5468\u671F\u3001Composables",
+        "pinia": "Store \u5B9A\u4E49\u3001\u72B6\u6001\u7BA1\u7406\u3001\u6301\u4E45\u5316",
+        "flutter": "Widget \u8BBE\u8BA1\u3001\u72B6\u6001\u7BA1\u7406\u3001\u6027\u80FD\u4F18\u5316",
+        "flutter-ui-system": "Design Token\u3001Flex\u7EC4\u4EF6\u3001\u4E3B\u9898\u7CFB\u7EDF\u3001$\u5FEB\u6377\u65B9\u5F0F",
+        "wechat-miniprogram": "Page/Component\u3001\u7F51\u7EDC\u8BF7\u6C42\u3001\u6027\u80FD\u4F18\u5316"
+      },
+      libraries: {
+        "element-plus": "\u8868\u5355\u3001\u8868\u683C\u3001\u5BF9\u8BDD\u6846\u3001\u6D88\u606F\u63D0\u793A",
+        "i18n": "\u7FFB\u8BD1\u6587\u4EF6\u3001\u7EC4\u4EF6\u4F7F\u7528\u3001\u53C2\u6570\u5316"
+      },
+      patterns: {
+        "api-layer": "Axios \u914D\u7F6E\u3001API \u6A21\u5757\u5316\u3001\u9519\u8BEF\u5904\u7406",
+        "component-design": "\u7EC4\u4EF6\u901A\u4FE1\u3001Props \u9A8C\u8BC1\u3001\u6027\u80FD\u4F18\u5316",
+        "vue-css-nesting": "\u539F\u751F\u5D4C\u5957\u8BED\u6CD5\u3001\u4F2A\u7C7B\u4F2A\u5143\u7D20\u3001\u6DF1\u5EA6\u9009\u62E9\u5668",
+        "vue-api-mock-layer": "Axios\u5C01\u88C5\u3001Mock\u6570\u636E\u3001\u6A21\u5757\u5316API"
+      }
+    };
+    return ((_a = descMap[category]) == null ? void 0 : _a[standardId]) || "";
+  }
+  /**
+   * 更新平均响应时间
+   */
+  updateAverageResponseTime(responseTime) {
+    const { totalCalls, averageResponseTime } = this.metrics;
+    this.metrics.totalCalls++;
+    this.metrics.averageResponseTime = (averageResponseTime * totalCalls + responseTime) / this.metrics.totalCalls;
+  }
+  /**
+   * 获取性能指标
+   */
+  getPerformanceMetrics() {
+    return {
+      ...this.metrics,
+      cacheHitRate: this.metrics.totalCalls > 0 ? (this.metrics.cacheHits / this.metrics.totalCalls * 100).toFixed(2) + "%" : "0%"
+    };
+  }
+  /**
+   * 获取使用统计
+   */
+  getUsageStats() {
+    const topCombinations = Array.from(this.stats.standardCombinations.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([combination, count]) => ({ combination, count }));
+    const topStandards = Array.from(this.stats.individualStandards.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([standard, count]) => ({ standard, count }));
+    return {
+      topCombinations,
+      topStandards,
+      totalCalls: this.stats.totalCalls
+    };
+  }
+  /**
+   * 清除缓存
+   */
+  clearCache() {
+    this.contentCache.clear();
+    console.log("[StandardsManager] Cache cleared");
+  }
+  /**
+   * 获取缓存统计
+   */
+  getCacheStats() {
+    const entries = Array.from(this.contentCache.entries()).map(([uri, entry]) => ({
+      uri,
+      accessCount: entry.accessCount,
+      age: Math.floor((Date.now() - entry.timestamp) / 1e3)
+      // 秒
+    })).sort((a, b) => b.accessCount - a.accessCount);
+    return {
+      size: this.contentCache.size,
+      maxSize: this.MAX_CACHE_SIZE,
+      entries
+    };
+  }
+};
+
+// src/core/autoInitializer.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+var AutoInitializer = class {
+  constructor(logger3) {
+    this.logger = logger3;
+    this.initialized = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 检查并初始化项目配置
+   * @param workspacePath 工作区路径
+   * @returns 是否需要初始化（返回 true 表示已执行初始化）
+   */
+  async ensureProjectConfig(workspacePath) {
+    var _a, _b, _c, _d;
+    const projectPath = workspacePath || this.detectWorkspacePath();
+    if (!projectPath) {
+      return {
+        needsInit: false,
+        initialized: false,
+        message: "\u672A\u68C0\u6D4B\u5230\u5DE5\u4F5C\u533A\u8DEF\u5F84"
+      };
+    }
+    if (this.initialized.get(projectPath)) {
+      return {
+        needsInit: false,
+        initialized: true,
+        message: `\u9879\u76EE\u5DF2\u914D\u7F6E: ${path8.basename(projectPath)}`
+      };
+    }
+    const configPath = path8.join(projectPath, ".github", "copilot-instructions.md");
+    const hasConfig = fs7.existsSync(configPath);
+    if (hasConfig) {
+      this.initialized.set(projectPath, true);
+      return {
+        needsInit: false,
+        initialized: true,
+        message: `\u9879\u76EE\u5DF2\u6709\u914D\u7F6E: ${path8.basename(projectPath)}`
+      };
+    }
+    this.log(`\u{1F50D} \u68C0\u6D4B\u5230\u9879\u76EE\u672A\u914D\u7F6E\uFF0C\u5F00\u59CB\u81EA\u52A8\u5206\u6790\u548C\u751F\u6210\u914D\u7F6E...`);
+    this.log(`\u{1F4C1} \u9879\u76EE\u8DEF\u5F84: ${projectPath}`);
+    try {
+      this.log("1\uFE0F\u20E3 \u5206\u6790\u9879\u76EE\u6280\u672F\u6808...");
+      const analysisResult = await analyzeProject({ projectPath });
+      if ((_b = (_a = analysisResult.content) == null ? void 0 : _a[0]) == null ? void 0 : _b.text) {
+        const analysis = JSON.parse(analysisResult.content[0].text);
+        this.log(`\u2705 \u68C0\u6D4B\u5230: ${((_c = analysis.frameworks) == null ? void 0 : _c.join(", ")) || "\u672A\u77E5\u6280\u672F\u6808"}`);
+        this.log("2\uFE0F\u20E3 \u751F\u6210\u9879\u76EE\u914D\u7F6E\u6587\u4EF6...");
+        await generateConfig({
+          projectPath,
+          autoMatch: true
+        });
+        this.initialized.set(projectPath, true);
+        return {
+          needsInit: true,
+          initialized: true,
+          message: `\u2705 \u9879\u76EE\u914D\u7F6E\u5DF2\u81EA\u52A8\u751F\u6210
+\u{1F4C1} \u8DEF\u5F84: ${configPath}
+\u{1F3AF} \u6280\u672F\u6808: ${(_d = analysis.frameworks) == null ? void 0 : _d.join(", ")}`
+        };
+      }
+    } catch (error) {
+      this.log(`\u274C \u81EA\u52A8\u521D\u59CB\u5316\u5931\u8D25: ${error}`);
+      return {
+        needsInit: true,
+        initialized: false,
+        message: `\u26A0\uFE0F \u81EA\u52A8\u521D\u59CB\u5316\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    return {
+      needsInit: true,
+      initialized: false,
+      message: "\u26A0\uFE0F \u65E0\u6CD5\u5B8C\u6210\u81EA\u52A8\u521D\u59CB\u5316"
+    };
+  }
+  /**
+   * 检测工作区路径
+   */
+  detectWorkspacePath() {
+    if (process.env.WORKSPACE_PATH) {
+      return process.env.WORKSPACE_PATH;
+    }
+    const cwd = process.cwd();
+    if (this.isValidProject(cwd)) {
+      return cwd;
+    }
+    const possiblePaths = [
+      path8.join(cwd, ".."),
+      path8.join(cwd, "../..")
+    ];
+    for (const possiblePath of possiblePaths) {
+      if (this.isValidProject(possiblePath)) {
+        return possiblePath;
+      }
+    }
+    return null;
+  }
+  /**
+   * 判断是否是有效的项目目录
+   */
+  isValidProject(dirPath) {
+    if (!fs7.existsSync(dirPath)) {
+      return false;
+    }
+    const markers = [
+      "package.json",
+      "pubspec.yaml",
+      "pom.xml",
+      "go.mod",
+      "Cargo.toml",
+      ".git"
+    ];
+    return markers.some(
+      (marker) => fs7.existsSync(path8.join(dirPath, marker))
+    );
+  }
+  /**
+   * 重置初始化状态（用于测试）
+   */
+  reset() {
+    this.initialized.clear();
+  }
+  log(message) {
+    if (this.logger) {
+      this.logger.log(message);
+    } else {
+      console.error(`[AutoInit] ${message}`);
+    }
+  }
+};
+
+// src/tools/getSmartStandards.ts
+async function getSmartStandards(args) {
+  var _a;
+  const logger3 = new ConsoleLogger();
+  const manager = new StandardsManager();
+  const autoInit = new AutoInitializer(logger3);
+  try {
+    const initResult = await autoInit.ensureProjectConfig();
+    if (initResult.needsInit) {
+      logger3.log("\u{1F4CB} " + initResult.message);
+      if (initResult.initialized) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u{1F389} **\u9996\u6B21\u4F7F\u7528\u81EA\u52A8\u914D\u7F6E\u5B8C\u6210**
+
+${initResult.message}
+
+\u73B0\u5728\u53EF\u4EE5\u7EE7\u7EED\u4F7F\u7528 @mta \u8FDB\u884C\u5F00\u53D1\u4E86\uFF01
+
+\u{1F4A1} \u63D0\u793A\uFF1A\u9879\u76EE\u914D\u7F6E\u6587\u4EF6\u5DF2\u751F\u6210\u5728 .github/copilot-instructions.md`
+          }]
+        };
+      }
+    }
+    let detectedFileType = "unknown";
+    let detectedImports = [];
+    let detectedScenario = "";
+    let analysisSource = "none";
+    if (args.currentFile && fs8.existsSync(args.currentFile)) {
+      analysisSource = "file-path";
+      const ext = ((_a = args.currentFile.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
+      const extMap = {
+        "vue": "vue",
+        "ts": "ts",
+        "tsx": "tsx",
+        "js": "js",
+        "jsx": "jsx"
+      };
+      detectedFileType = extMap[ext] || "unknown";
+      try {
+        const content = fs8.readFileSync(args.currentFile, "utf-8");
+        const imports = extractImports(content);
+        detectedImports = imports;
+        detectedScenario = inferScenario(content, detectedFileType);
+      } catch {
+        logger3.log("\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\uFF0C\u4EC5\u4F7F\u7528\u6587\u4EF6\u7C7B\u578B");
+      }
+    }
+    if (args.fileContent) {
+      analysisSource = "file-content";
+      const imports = extractImports(args.fileContent);
+      detectedImports = [...detectedImports, ...imports];
+      if (detectedFileType === "unknown") {
+        if (args.fileContent.includes("<template>")) {
+          detectedFileType = "vue";
+        } else if (args.fileContent.includes("interface ") || args.fileContent.includes("type ")) {
+          detectedFileType = "ts";
+        }
+      }
+      const scenario = inferScenario(args.fileContent, detectedFileType);
+      if (scenario) detectedScenario = scenario;
+    }
+    if (detectedFileType === "unknown") {
+      analysisSource = "environment";
+      const cwd = process.cwd();
+      const packageJsonPath = `${cwd}/package.json`;
+      if (fs8.existsSync(packageJsonPath)) {
+        try {
+          const pkg = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          if (deps["vue"]) {
+            detectedFileType = "vue";
+            detectedImports.push("vue");
+          }
+          if (deps["react"]) {
+            detectedFileType = "tsx";
+            detectedImports.push("react");
+          }
+          if (deps["element-plus"]) detectedImports.push("element-plus");
+          if (deps["pinia"]) detectedImports.push("pinia");
+          if (deps["vue-i18n"]) detectedImports.push("vue-i18n");
+        } catch {
+          logger3.log("\u65E0\u6CD5\u89E3\u6790 package.json");
+        }
+      }
+    }
+    detectedImports = [...new Set(detectedImports)];
+    logger3.log(`\u{1F50D} \u667A\u80FD\u68C0\u6D4B\u7ED3\u679C: fileType=${detectedFileType}, imports=${detectedImports.join(",")}, scenario=${detectedScenario}`);
+    const standards = manager.getRelevantStandards({
+      fileType: detectedFileType !== "unknown" ? detectedFileType : void 0,
+      imports: detectedImports.length > 0 ? detectedImports : void 0,
+      scenario: detectedScenario || void 0
+    });
+    const combinedContent = manager.combineStandards(standards);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          analysis: {
+            source: analysisSource,
+            fileType: detectedFileType,
+            imports: detectedImports,
+            scenario: detectedScenario
+          },
+          standards,
+          content: combinedContent,
+          stats: {
+            standardsCount: standards.length,
+            contentLength: combinedContent.length,
+            estimatedTokens: Math.ceil(combinedContent.length / 4)
+          }
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u667A\u80FD\u89C4\u8303\u63A8\u8350\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+function extractImports(content) {
+  const imports = [];
+  const es6Regex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = es6Regex.exec(content)) !== null) {
+    const pkg = match[1];
+    if (!pkg.startsWith(".") && !pkg.startsWith("/")) {
+      imports.push(pkg.split("/")[0]);
+    }
+  }
+  const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = requireRegex.exec(content)) !== null) {
+    const pkg = match[1];
+    if (!pkg.startsWith(".") && !pkg.startsWith("/")) {
+      imports.push(pkg.split("/")[0]);
+    }
+  }
+  return [...new Set(imports)];
+}
+function inferScenario(content, fileType) {
+  const scenarios = [];
+  if (fileType === "vue") {
+    if (content.includes("ElForm") || content.includes("<el-form")) {
+      scenarios.push("\u8868\u5355\u7EC4\u4EF6");
+    }
+    if (content.includes("ElTable") || content.includes("<el-table")) {
+      scenarios.push("\u8868\u683C\u7EC4\u4EF6");
+    }
+    if (content.includes("defineStore")) {
+      scenarios.push("\u72B6\u6001\u7BA1\u7406");
+    }
+    if (content.includes("useI18n") || content.includes("$t(")) {
+      scenarios.push("\u56FD\u9645\u5316");
+    }
+  }
+  if (content.includes("fetch(") || content.includes("axios.")) {
+    scenarios.push("API \u8C03\u7528");
+  }
+  if (content.includes("interface ") || content.includes("type ")) {
+    scenarios.push("\u7C7B\u578B\u5B9A\u4E49");
+  }
+  return scenarios.join("\u3001");
+}
+
+// src/tools/usePreset.ts
+var PRESETS = {
+  "vue3-component": {
+    name: "Vue 3 \u7EC4\u4EF6\u5F00\u53D1",
+    fileType: "vue",
+    imports: ["vue", "element-plus"],
+    scenario: "\u7EC4\u4EF6\u5F00\u53D1",
+    description: "\u5F00\u53D1 Vue 3 \u5355\u6587\u4EF6\u7EC4\u4EF6\uFF0C\u5305\u542B Composition API \u548C Element Plus"
+  },
+  "vue3-form": {
+    name: "Vue 3 \u8868\u5355\u5F00\u53D1",
+    fileType: "vue",
+    imports: ["vue", "element-plus"],
+    scenario: "\u8868\u5355\u7EC4\u4EF6",
+    description: "Element Plus \u8868\u5355\u7EC4\u4EF6\u5F00\u53D1\uFF0C\u5305\u542B\u9A8C\u8BC1\u548C\u56FD\u9645\u5316"
+  },
+  "vue3-table": {
+    name: "Vue 3 \u8868\u683C\u5F00\u53D1",
+    fileType: "vue",
+    imports: ["vue", "element-plus"],
+    scenario: "\u8868\u683C\u7EC4\u4EF6",
+    description: "Element Plus \u8868\u683C\u7EC4\u4EF6\u5F00\u53D1\uFF0C\u5305\u542B\u5206\u9875\u548C\u64CD\u4F5C"
+  },
+  "pinia-store": {
+    name: "Pinia \u72B6\u6001\u7BA1\u7406",
+    fileType: "ts",
+    imports: ["vue", "pinia"],
+    scenario: "\u72B6\u6001\u7BA1\u7406",
+    description: "Pinia store \u5B9A\u4E49\uFF0C\u5305\u542B actions\u3001getters \u548C\u6301\u4E45\u5316"
+  },
+  "api-call": {
+    name: "API \u8C03\u7528\u5C42",
+    fileType: "ts",
+    imports: ["axios"],
+    scenario: "API \u8C03\u7528",
+    description: "RESTful API \u8C03\u7528\u5C01\u88C5\uFF0C\u5305\u542B\u9519\u8BEF\u5904\u7406\u548C\u7C7B\u578B\u5B9A\u4E49"
+  },
+  "typescript-strict": {
+    name: "TypeScript \u4E25\u683C\u6A21\u5F0F",
+    fileType: "ts",
+    imports: [],
+    scenario: "\u7C7B\u578B\u5B9A\u4E49",
+    description: "TypeScript \u4E25\u683C\u7C7B\u578B\u5B9A\u4E49\u548C\u7C7B\u578B\u5B88\u536B"
+  },
+  "i18n": {
+    name: "\u56FD\u9645\u5316\u5F00\u53D1",
+    fileType: "vue",
+    imports: ["vue", "vue-i18n"],
+    scenario: "\u56FD\u9645\u5316",
+    description: "Vue I18n \u591A\u8BED\u8A00\u652F\u6301\uFF0C\u5305\u542B\u7FFB\u8BD1\u6587\u4EF6\u7BA1\u7406"
+  },
+  "composable": {
+    name: "Vue 3 Composable",
+    fileType: "ts",
+    imports: ["vue"],
+    scenario: "\u53EF\u7EC4\u5408\u51FD\u6570",
+    description: "Vue 3 \u7EC4\u5408\u5F0F\u51FD\u6570\u5F00\u53D1\uFF0C\u590D\u7528\u903B\u8F91"
+  }
+};
+async function usePreset(args) {
+  const logger3 = new ConsoleLogger();
+  const manager = new StandardsManager();
+  try {
+    if (!(args.preset in PRESETS)) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: `\u672A\u77E5\u7684\u9884\u8BBE: ${args.preset}`,
+            availablePresets: Object.keys(PRESETS).map((id) => ({
+              id,
+              name: PRESETS[id].name,
+              description: PRESETS[id].description
+            }))
+          }, null, 2)
+        }]
+      };
+    }
+    const preset = PRESETS[args.preset];
+    logger3.log(`\u{1F3AF} \u4F7F\u7528\u9884\u8BBE: ${preset.name}`);
+    const imports = args.customImports ? [...preset.imports, ...args.customImports] : [...preset.imports];
+    const standards = manager.getRelevantStandards({
+      fileType: preset.fileType,
+      imports: imports.length > 0 ? imports : void 0,
+      scenario: preset.scenario
+    });
+    const combinedContent = manager.combineStandards(standards);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          preset: {
+            id: args.preset,
+            name: preset.name,
+            description: preset.description
+          },
+          applied: {
+            fileType: preset.fileType,
+            imports,
+            scenario: preset.scenario
+          },
+          standards,
+          content: combinedContent,
+          stats: {
+            standardsCount: standards.length,
+            contentLength: combinedContent.length,
+            estimatedTokens: Math.ceil(combinedContent.length / 4)
+          }
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u4F7F\u7528\u9884\u8BBE\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+async function listPresets() {
+  const presetList = Object.entries(PRESETS).map(([id, preset]) => ({
+    id,
+    name: preset.name,
+    description: preset.description,
+    fileType: preset.fileType,
+    imports: preset.imports,
+    scenario: preset.scenario
+  }));
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        success: true,
+        total: presetList.length,
+        presets: presetList,
+        usage: "\u4F7F\u7528\u65B9\u5F0F: \u8C03\u7528 use_preset \u5DE5\u5177\u5E76\u6307\u5B9A preset \u53C2\u6570"
+      }, null, 2)
+    }]
+  };
+}
+
+// src/tools/healthCheck.ts
+import * as fs9 from "fs";
+import * as path9 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = path9.dirname(__filename4);
+async function healthCheck(args) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const logger3 = new ConsoleLogger();
+  const verbose = (_a = args.verbose) != null ? _a : false;
+  try {
+    const checks = {
+      server: { status: "unknown", details: [] },
+      configuration: { status: "unknown", details: [] },
+      dependencies: { status: "unknown", details: [] },
+      standards: { status: "unknown", details: [] },
+      workspace: { status: "unknown", details: [] }
+    };
+    logger3.log("\u{1F50D} \u68C0\u67E5\u670D\u52A1\u5668\u72B6\u6001...");
+    try {
+      checks.server.status = "healthy";
+      checks.server.details.push("\u2705 MCP \u670D\u52A1\u5668\u6B63\u5728\u8FD0\u884C");
+      checks.server.details.push(`\u{1F4CD} \u8FDB\u7A0B PID: ${process.pid}`);
+      checks.server.details.push(`\u{1F550} \u8FD0\u884C\u65F6\u95F4: ${Math.floor(process.uptime())}\u79D2`);
+    } catch {
+      checks.server.status = "error";
+      checks.server.details.push("\u274C \u670D\u52A1\u5668\u672A\u54CD\u5E94");
+    }
+    logger3.log("\u{1F50D} \u68C0\u67E5\u914D\u7F6E\u6587\u4EF6...");
+    const workspacePath = args.workspacePath || process.cwd();
+    const vscodeDir = path9.join(workspacePath, ".vscode");
+    if (fs9.existsSync(vscodeDir)) {
+      checks.workspace.status = "healthy";
+      checks.workspace.details.push(`\u2705 \u5DE5\u4F5C\u533A\u8DEF\u5F84: ${workspacePath}`);
+      const mcpJsonPath = path9.join(vscodeDir, "mcp.json");
+      if (fs9.existsSync(mcpJsonPath)) {
+        try {
+          const config = JSON.parse(fs9.readFileSync(mcpJsonPath, "utf-8"));
+          const hasNewFormat = (_b = config.servers) == null ? void 0 : _b["copilot-prompts"];
+          const hasOldFormat = (_c = config.mcpServers) == null ? void 0 : _c["copilot-prompts"];
+          if (hasNewFormat) {
+            checks.configuration.status = "healthy";
+            checks.configuration.details.push("\u2705 mcp.json \u914D\u7F6E\u6B63\u786E (\u4F7F\u7528\u65B0\u683C\u5F0F)");
+            const serverConfig = config.servers["copilot-prompts"];
+            if (verbose) {
+              checks.configuration.details.push(`  Command: ${serverConfig.command}`);
+              checks.configuration.details.push(`  Args: ${(_d = serverConfig.args) == null ? void 0 : _d.join(" ")}`);
+              checks.configuration.details.push(`  AutoStart: ${(_e = serverConfig.autoStart) != null ? _e : "undefined"}`);
+              checks.configuration.details.push(`  Env: ${JSON.stringify((_f = serverConfig.env) != null ? _f : {})}`);
+            }
+            if (!serverConfig.env) {
+              checks.configuration.details.push('\u{1F4A1} \u5EFA\u8BAE: \u6DFB\u52A0 "env": {} \u5B57\u6BB5');
+            }
+            if (!serverConfig.autoStart) {
+              checks.configuration.details.push('\u{1F4A1} \u5EFA\u8BAE: \u6DFB\u52A0 "autoStart": true \u5B57\u6BB5');
+            }
+          } else if (hasOldFormat) {
+            checks.configuration.status = "warning";
+            checks.configuration.details.push("\u26A0\uFE0F  mcp.json \u4F7F\u7528\u65E7\u683C\u5F0F (mcpServers)");
+            checks.configuration.details.push("\u{1F4A1} \u5EFA\u8BAE: \u8FD0\u884C auto_setup \u5DE5\u5177\u5347\u7EA7\u5230\u65B0\u683C\u5F0F (servers)");
+            if (verbose) {
+              const serverConfig = config.mcpServers["copilot-prompts"];
+              checks.configuration.details.push(`  Command: ${serverConfig.command}`);
+              checks.configuration.details.push(`  Args: ${(_g = serverConfig.args) == null ? void 0 : _g.join(" ")}`);
+            }
+          } else {
+            checks.configuration.status = "warning";
+            checks.configuration.details.push("\u26A0\uFE0F  mcp.json \u7F3A\u5C11 copilot-prompts \u914D\u7F6E");
+            checks.configuration.details.push("\u{1F4A1} \u5EFA\u8BAE: \u8FD0\u884C auto_setup \u5DE5\u5177\u6DFB\u52A0\u914D\u7F6E");
+          }
+        } catch (error) {
+          checks.configuration.status = "error";
+          checks.configuration.details.push(`\u274C mcp.json \u683C\u5F0F\u9519\u8BEF: ${error}`);
+          checks.configuration.details.push("\u{1F4A1} \u4FEE\u590D: \u8FD0\u884C auto_setup \u5DE5\u5177\u91CD\u65B0\u751F\u6210\u914D\u7F6E");
+        }
+      } else {
+        checks.configuration.status = "warning";
+        checks.configuration.details.push("\u26A0\uFE0F  mcp.json \u4E0D\u5B58\u5728");
+        checks.configuration.details.push("\u{1F4A1} \u5EFA\u8BAE: \u8FD0\u884C auto_setup \u5DE5\u5177\u81EA\u52A8\u914D\u7F6E");
+      }
+      const settingsPath = path9.join(vscodeDir, "settings.json");
+      if (fs9.existsSync(settingsPath)) {
+        try {
+          const settings = JSON.parse(fs9.readFileSync(settingsPath, "utf-8"));
+          if (settings["github.copilot.chat.mcp.enabled"] === true) {
+            checks.configuration.details.push("\u2705 VS Code MCP \u5DF2\u542F\u7528");
+          } else {
+            checks.configuration.details.push("\u26A0\uFE0F  VS Code MCP \u672A\u542F\u7528");
+          }
+        } catch {
+          checks.configuration.details.push("\u26A0\uFE0F  settings.json \u683C\u5F0F\u9519\u8BEF");
+        }
+      }
+    } else {
+      checks.workspace.status = "error";
+      checks.workspace.details.push("\u274C .vscode \u76EE\u5F55\u4E0D\u5B58\u5728");
+    }
+    logger3.log("\u{1F50D} \u68C0\u67E5\u4F9D\u8D56...");
+    const serverRoot = path9.resolve(__dirname4, "../..");
+    const packageJsonPath = path9.join(serverRoot, "package.json");
+    if (fs9.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8"));
+        checks.dependencies.status = "healthy";
+        checks.dependencies.details.push(`\u2705 \u670D\u52A1\u5668\u7248\u672C: ${pkg.version}`);
+        if (verbose && pkg.dependencies) {
+          const deps = Object.entries(pkg.dependencies).slice(0, 3);
+          deps.forEach(([name, version]) => {
+            checks.dependencies.details.push(`  ${name}: ${version}`);
+          });
+        }
+        const requiredDeps = ["@modelcontextprotocol/sdk"];
+        const missing = requiredDeps.filter((dep) => {
+          var _a2;
+          return !((_a2 = pkg.dependencies) == null ? void 0 : _a2[dep]);
+        });
+        if (missing.length > 0) {
+          checks.dependencies.status = "error";
+          checks.dependencies.details.push(`\u274C \u7F3A\u5C11\u4F9D\u8D56: ${missing.join(", ")}`);
+        }
+      } catch {
+        checks.dependencies.status = "error";
+        checks.dependencies.details.push("\u274C \u65E0\u6CD5\u8BFB\u53D6 package.json");
+      }
+    }
+    logger3.log("\u{1F50D} \u68C0\u67E5\u89C4\u8303\u6587\u4EF6...");
+    const standardsDir = path9.join(serverRoot, "standards");
+    if (fs9.existsSync(standardsDir)) {
+      const categories = ["core", "frameworks", "libraries", "patterns"];
+      const foundStandards = [];
+      for (const category of categories) {
+        const categoryPath = path9.join(standardsDir, category);
+        if (fs9.existsSync(categoryPath)) {
+          const files = fs9.readdirSync(categoryPath).filter((f) => f.endsWith(".md"));
+          foundStandards.push(...files.map((f) => `${category}/${f}`));
+        }
+      }
+      if (foundStandards.length > 0) {
+        checks.standards.status = "healthy";
+        checks.standards.details.push(`\u2705 \u627E\u5230 ${foundStandards.length} \u4E2A\u89C4\u8303\u6587\u4EF6`);
+        if (verbose) {
+          foundStandards.slice(0, 5).forEach((s) => {
+            checks.standards.details.push(`  \u{1F4C4} ${s}`);
+          });
+          if (foundStandards.length > 5) {
+            checks.standards.details.push(`  ... \u8FD8\u6709 ${foundStandards.length - 5} \u4E2A\u6587\u4EF6`);
+          }
+        }
+      } else {
+        checks.standards.status = "warning";
+        checks.standards.details.push("\u26A0\uFE0F  \u672A\u627E\u5230\u89C4\u8303\u6587\u4EF6");
+      }
+    } else {
+      checks.standards.status = "error";
+      checks.standards.details.push("\u274C standards \u76EE\u5F55\u4E0D\u5B58\u5728");
+    }
+    const allStatuses = Object.values(checks).map((c) => c.status);
+    const overallStatus = allStatuses.includes("error") ? "error" : allStatuses.includes("warning") ? "warning" : "healthy";
+    const statusEmoji = {
+      healthy: "\u2705",
+      warning: "\u26A0\uFE0F",
+      error: "\u274C",
+      unknown: "\u2753"
+    };
+    logger3.log(`${statusEmoji[overallStatus]} \u5065\u5EB7\u68C0\u67E5\u5B8C\u6210`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          overallStatus,
+          summary: `${statusEmoji[overallStatus]} MCP \u670D\u52A1\u5668\u72B6\u6001: ${overallStatus}`,
+          checks,
+          recommendations: generateRecommendations(checks)
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+function generateRecommendations(checks) {
+  const recommendations = [];
+  if (checks.configuration.status !== "healthy") {
+    recommendations.push("\u{1F527} \u8FD0\u884C auto_setup \u5DE5\u5177\u81EA\u52A8\u914D\u7F6E MCP \u670D\u52A1\u5668");
+  }
+  if (checks.workspace.status === "error") {
+    recommendations.push("\u{1F4C1} \u786E\u4FDD\u5728\u6B63\u786E\u7684\u5DE5\u4F5C\u533A\u76EE\u5F55\u4E2D\u8FD0\u884C");
+  }
+  if (checks.dependencies.status === "error") {
+    recommendations.push("\u{1F4E6} \u8FD0\u884C npm install \u5B89\u88C5\u4F9D\u8D56");
+  }
+  if (checks.standards.status !== "healthy") {
+    recommendations.push("\u{1F4DA} \u68C0\u67E5 standards \u76EE\u5F55\u662F\u5426\u5B58\u5728\u89C4\u8303\u6587\u4EF6");
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("\u{1F389} \u4E00\u5207\u6B63\u5E38\uFF01\u60A8\u53EF\u4EE5\u5F00\u59CB\u4F7F\u7528 MCP \u670D\u52A1\u5668\u4E86");
+  }
+  return recommendations;
+}
+
+// src/tools/getCompactStandards.ts
+import * as fs10 from "fs";
+async function getCompactStandards(args) {
+  const logger3 = new ConsoleLogger();
+  const manager = new StandardsManager();
+  const mode = args.mode || "key-rules";
+  try {
+    const context = detectContext(args, logger3);
+    const standardUris = manager.getRelevantStandards({
+      fileType: context.fileType,
+      imports: context.imports,
+      scenario: args.scenario || context.scenario
+    });
+    let responseContent;
+    switch (mode) {
+      case "summary":
+        responseContent = buildSummaryResponse(standardUris, manager);
+        break;
+      case "key-rules":
+        responseContent = buildKeyRulesResponse(standardUris, context, manager);
+        break;
+      case "full":
+        responseContent = buildFullResponse(standardUris, manager);
+        break;
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(responseContent, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u89C4\u8303\u83B7\u53D6\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+function detectContext(args, logger3) {
+  var _a;
+  let fileType = "unknown";
+  let imports = [];
+  let scenario = "";
+  if (args.currentFile && fs10.existsSync(args.currentFile)) {
+    const ext = ((_a = args.currentFile.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
+    const extMap = {
+      "vue": "vue",
+      "ts": "ts",
+      "tsx": "tsx",
+      "js": "js",
+      "jsx": "jsx",
+      "dart": "dart"
+    };
+    fileType = extMap[ext] || "unknown";
+    try {
+      const content = fs10.readFileSync(args.currentFile, "utf-8");
+      imports = extractImports2(content);
+      scenario = inferScenario2(content, fileType);
+    } catch {
+    }
+  }
+  if (args.fileContent) {
+    imports = [...imports, ...extractImports2(args.fileContent)];
+    if (fileType === "unknown") {
+      if (args.fileContent.includes("<template>")) fileType = "vue";
+      else if (args.fileContent.includes("interface ")) fileType = "ts";
+    }
+    scenario = scenario || inferScenario2(args.fileContent, fileType);
+  }
+  return { fileType, imports: [...new Set(imports)], scenario };
+}
+function buildSummaryResponse(uris, manager) {
+  const standards = manager.getAvailableStandards();
+  const matched = uris.map((uri) => {
+    const std = standards.find((s) => s.uri === uri);
+    return {
+      uri,
+      name: (std == null ? void 0 : std.name) || uri,
+      description: (std == null ? void 0 : std.description) || ""
+    };
+  });
+  return {
+    success: true,
+    mode: "summary",
+    message: '\u5DF2\u8BC6\u522B\u76F8\u5173\u89C4\u8303\uFF0C\u5982\u9700\u8BE6\u7EC6\u5185\u5BB9\u8BF7\u4F7F\u7528 mode: "key-rules" \u6216 "full"',
+    standards: matched,
+    stats: {
+      count: matched.length,
+      estimatedTokens: 500
+    }
+  };
+}
+function buildKeyRulesResponse(uris, context, manager) {
+  const keyRules = [];
+  if (context.fileType === "vue") {
+    keyRules.push(...getVueKeyRules(context.imports));
+  } else if (context.fileType === "dart") {
+    keyRules.push(...getFlutterKeyRules());
+  } else if (context.fileType === "ts" || context.fileType === "tsx") {
+    keyRules.push(...getTypeScriptKeyRules());
+  }
+  if (context.imports.includes("element-plus")) {
+    keyRules.push(...getElementPlusKeyRules());
+  }
+  if (context.imports.some((i) => i.includes("i18n") || i.includes("locale"))) {
+    keyRules.push(...getI18nKeyRules());
+  }
+  if (context.imports.includes("pinia")) {
+    keyRules.push(...getPiniaKeyRules());
+  }
+  return {
+    success: true,
+    mode: "key-rules",
+    context: {
+      fileType: context.fileType,
+      detectedImports: context.imports,
+      scenario: context.scenario
+    },
+    keyRules: keyRules.join("\n\n"),
+    standardUris: uris,
+    // 提供完整 URI 供按需加载
+    stats: {
+      rulesCount: keyRules.length,
+      estimatedTokens: Math.ceil(keyRules.join("").length / 4)
+    }
+  };
+}
+function buildFullResponse(uris, manager) {
+  const content = manager.combineStandards(uris);
+  return {
+    success: true,
+    mode: "full",
+    standards: uris,
+    content,
+    stats: {
+      standardsCount: uris.length,
+      contentLength: content.length,
+      estimatedTokens: Math.ceil(content.length / 4)
+    }
+  };
+}
+function getVueKeyRules(imports) {
+  return [
+    `## Vue 3 \u5173\u952E\u89C4\u5219
+
+1. **\u4F7F\u7528 \`<script setup lang="ts">\`** - \u5FC5\u987B\u4F7F\u7528 Composition API
+2. **Props/Emits \u7C7B\u578B\u5B9A\u4E49** - \u5FC5\u987B\u4F7F\u7528 interface \u5B9A\u4E49\u7C7B\u578B
+3. **\u7981\u6B62\u5185\u8054\u6837\u5F0F** - \u4F7F\u7528 scoped CSS \u6216 class
+4. **\u6A21\u677F\u7B80\u6D01** - \u590D\u6742\u903B\u8F91\u63D0\u53D6\u5230 computed \u6216\u65B9\u6CD5
+5. **\u54CD\u5E94\u5F0F** - \u57FA\u672C\u7C7B\u578B\u7528 ref\uFF0C\u5BF9\u8C61\u7528 reactive\uFF08\u4E0D\u91CD\u65B0\u8D4B\u503C\uFF09`,
+    `## \u7EC4\u4EF6\u7ED3\u6784\u987A\u5E8F
+\`\`\`vue
+<script setup lang="ts">
+// 1. \u7C7B\u578B\u5BFC\u5165
+// 2. Props/Emits \u5B9A\u4E49
+// 3. \u54CD\u5E94\u5F0F\u72B6\u6001
+// 4. \u8BA1\u7B97\u5C5E\u6027
+// 5. \u65B9\u6CD5
+// 6. \u751F\u547D\u5468\u671F
+</script>
+\`\`\``
+  ];
+}
+function getElementPlusKeyRules() {
+  return [
+    `## Element Plus \u5173\u952E\u89C4\u5219
+
+### \u8868\u683C\u89C4\u8303
+- **\u5FC5\u987B** \`border\` + \`highlight-current-row\`
+- \u64CD\u4F5C\u5217 \`fixed="right"\`\uFF0C\u5BBD\u5EA6\uFF1A2\u6309\u94AE160px/3\u6309\u94AE240px/4\u6309\u94AE280px
+- \u4F7F\u7528 \`v-loading\` \u663E\u793A\u52A0\u8F7D\u72B6\u6001
+
+### \u8868\u5355\u89C4\u8303
+- \u4F7F\u7528 \`label-position="top"\` \u6216 \`label-width="120px"\`
+- \u9A8C\u8BC1\u89C4\u5219\u4F7F\u7528 \`FormRules<T>\` \u7C7B\u578B
+- \u9A8C\u8BC1\u6D88\u606F\u5FC5\u987B\u56FD\u9645\u5316
+
+### \u5F39\u7A97\u89C4\u8303
+- \u4F7F\u7528 \`destroy-on-close\` \u91CD\u7F6E\u72B6\u6001
+- \u5BBD\u5EA6\uFF1A\u7B80\u5355500px/\u6807\u51C6700px/\u590D\u6742900px
+
+### \u6D88\u606F\u63D0\u793A
+\`\`\`typescript
+ElMessage.success($t('\u4FDD\u5B58\u6210\u529F'))
+ElMessageBox.confirm($t('\u786E\u8BA4\u5220\u9664\uFF1F'), $t('\u8B66\u544A'), { type: 'warning' })
+\`\`\``,
+    `## \u8868\u683C\u793A\u4F8B
+\`\`\`vue
+<el-table v-loading="listLoading" :data="list" border highlight-current-row>
+  <el-table-column type="index" :label="$t('\u5E8F\u53F7')" width="70" />
+  <el-table-column prop="name" :label="$t('\u540D\u79F0')" min-width="120" />
+  <el-table-column fixed="right" :label="$t('\u64CD\u4F5C')" width="240">
+    <template #default="{ row }">
+      <el-button link type="primary" @click="handleEdit(row)">{{ $t('\u7F16\u8F91') }}</el-button>
+      <el-button link type="danger" @click="handleDelete(row)">{{ $t('\u5220\u9664') }}</el-button>
+    </template>
+  </el-table-column>
+</el-table>
+\`\`\``
+  ];
+}
+function getI18nKeyRules() {
+  return [
+    `## \u56FD\u9645\u5316\u5173\u952E\u89C4\u5219
+
+### \u5FC5\u987B\u56FD\u9645\u5316\u7684\u5185\u5BB9
+- \u6240\u6709\u6309\u94AE\u6587\u5B57\uFF1A\`{{ $t('\u4FDD\u5B58') }}\`
+- \u8868\u5355\u6807\u7B7E\uFF1A\`:label="$t('\u5BA2\u6237\u540D\u79F0')"\`
+- \u5360\u4F4D\u7B26\uFF1A\`:placeholder="$t('\u8BF7\u8F93\u5165')"\`
+- \u8868\u683C\u5217\u6807\u9898\uFF1A\`:label="$t('\u8BA2\u5355\u7F16\u53F7')"\`
+- \u5F39\u7A97\u6807\u9898\uFF1A\`:title="$t('\u65B0\u589E\u5BA2\u6237')"\`
+- \u63D0\u793A\u6D88\u606F\uFF1A\`ElMessage.success($t('\u4FDD\u5B58\u6210\u529F'))\`
+- \u9A8C\u8BC1\u89C4\u5219\uFF1A\`message: $t('\u8BF7\u8F93\u5165\u7528\u6237\u540D')\`
+
+### \u7981\u6B62
+- \u274C \`<el-button>\u65B0\u589E</el-button>\` (\u786C\u7F16\u7801)
+- \u274C \`label="\u5BA2\u6237\u540D\u79F0"\` (\u786C\u7F16\u7801)
+- \u274C \`ElMessage.success('\u4FDD\u5B58\u6210\u529F')\` (\u786C\u7F16\u7801)`
+  ];
+}
+function getPiniaKeyRules() {
+  return [
+    `## Pinia \u5173\u952E\u89C4\u5219
+
+### Setup Store \u8BED\u6CD5\uFF08\u63A8\u8350\uFF09
+\`\`\`typescript
+export const useUserStore = defineStore('user', () => {
+  const user = ref<User | null>(null)
+  const isLoggedIn = computed(() => !!user.value)
+  
+  async function login(credentials: Credentials) {
+    user.value = await authApi.login(credentials)
+  }
+  
+  return { user, isLoggedIn, login }
+})
+\`\`\`
+
+### \u89C4\u8303\u8981\u6C42
+- Store ID \u4F7F\u7528\u5C0F\u5199\u77ED\u6A2A\u7EBF\u547D\u540D
+- \u4F7F\u7528 Setup Store \u8BED\u6CD5\u800C\u975E Options Store
+- \u5F02\u6B65\u64CD\u4F5C\u76F4\u63A5\u7528 async/await
+- \u590D\u6742\u72B6\u6001\u64CD\u4F5C\u4F7F\u7528 $patch`
+  ];
+}
+function getTypeScriptKeyRules() {
+  return [
+    `## TypeScript \u5173\u952E\u89C4\u5219
+
+### \u7C7B\u578B\u5B9A\u4E49
+- \u5FC5\u987B\u5B9A\u4E49\u51FD\u6570\u53C2\u6570\u548C\u8FD4\u56DE\u7C7B\u578B
+- \u4F7F\u7528 interface \u5B9A\u4E49\u5BF9\u8C61\u7C7B\u578B
+- \u907F\u514D\u4F7F\u7528 any\uFF0C\u4F7F\u7528 unknown \u66FF\u4EE3
+
+### \u547D\u540D\u89C4\u8303
+- \u53D8\u91CF/\u51FD\u6570\uFF1AcamelCase
+- \u7C7B/\u63A5\u53E3/\u7C7B\u578B\uFF1APascalCase
+- \u5E38\u91CF\uFF1AUPPER_SNAKE_CASE
+
+### \u793A\u4F8B
+\`\`\`typescript
+interface User {
+  id: number
+  name: string
+  email?: string
+}
+
+async function fetchUser(id: number): Promise<User | null> {
+  // ...
+}
+\`\`\``
+  ];
+}
+function getFlutterKeyRules() {
+  return [
+    `## Flutter UI \u7CFB\u7EDF\u5173\u952E\u89C4\u5219
+
+### Design Token \u5FEB\u6377\u65B9\u5F0F\uFF08\u5FC5\u987B\u4F7F\u7528\uFF09
+| \u5FEB\u6377\u65B9\u5F0F | \u7528\u9014 | \u793A\u4F8B |
+|---------|------|------|
+| \`$c\` | \u989C\u8272 | \`$c.primary\`, \`$c.text.primary\` |
+| \`$s\` | \u95F4\u8DDD | \`$s.sm\`, \`$s.md\`, \`$s.px(14)\` |
+| \`$t\` | \u6392\u7248 | \`$t.displayLarge\`, \`$t.bodyMedium\` |
+| \`$r\` | \u5706\u89D2 | \`$r.sm\`, \`$r.md\`, \`$r.full\` |
+
+### Flex \u7EC4\u4EF6\u5E93\uFF08\u5FC5\u987B\u4F7F\u7528\uFF09
+- \`FlexButton\` \u66FF\u4EE3 ElevatedButton/TextButton
+- \`FlexCard\` \u66FF\u4EE3 Card/Container
+- \`FlexInput\` \u66FF\u4EE3 TextField
+- \`Gap\` \u66FF\u4EE3 SizedBox\uFF08\u95F4\u9694\uFF09
+
+### \u7981\u6B62
+- \u274C \`Color(0xFF3B82F6)\` \u786C\u7F16\u7801\u989C\u8272
+- \u274C \`EdgeInsets.all(16)\` \u786C\u7F16\u7801\u95F4\u8DDD
+- \u274C \`Colors.blue\` Material \u989C\u8272\u5E38\u91CF`
+  ];
+}
+function extractImports2(content) {
+  const imports = [];
+  const esImportRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = esImportRegex.exec(content)) !== null) {
+    imports.push(match[1]);
+  }
+  const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
+  while ((match = requireRegex.exec(content)) !== null) {
+    imports.push(match[1]);
+  }
+  return imports;
+}
+function inferScenario2(content, fileType) {
+  const scenarios = [];
+  const lower = content.toLowerCase();
+  if (lower.includes("el-table") || lower.includes("el-form")) {
+    scenarios.push("\u8868\u683C\u7EC4\u4EF6", "\u8868\u5355\u7EC4\u4EF6");
+  }
+  if (lower.includes("$t(") || lower.includes("i18n")) {
+    scenarios.push("\u56FD\u9645\u5316");
+  }
+  if (lower.includes("interface ") || lower.includes("type ")) {
+    scenarios.push("\u7C7B\u578B\u5B9A\u4E49");
+  }
+  return scenarios.join("\u3001");
+}
+
+// src/tools/getStandardById.ts
+import * as fs11 from "fs";
+import * as path10 from "path";
+var STANDARD_DIRS = [
+  "standards/core",
+  "standards/frameworks",
+  "standards/libraries",
+  "standards/patterns",
+  "standards/workflows"
+];
+var standardsCache = null;
+async function getStandardById(args) {
+  const logger3 = new ConsoleLogger();
+  const mode = args.mode || "key-rules";
+  try {
+    const idsToLoad = args.ids || (args.id ? [args.id] : []);
+    if (idsToLoad.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "\u8BF7\u63D0\u4F9B id \u6216 ids \u53C2\u6570",
+            availableIds: listAvailableStandards()
+          }, null, 2)
+        }]
+      };
+    }
+    ensureCache();
+    const results = [];
+    for (const id of idsToLoad) {
+      const filePath = standardsCache.get(id);
+      if (!filePath) {
+        results.push({
+          id,
+          found: false,
+          error: `\u89C4\u8303 "${id}" \u4E0D\u5B58\u5728`
+        });
+        continue;
+      }
+      try {
+        const fullContent = fs11.readFileSync(filePath, "utf-8");
+        const content = formatContent(fullContent, mode);
+        results.push({
+          id,
+          found: true,
+          content
+        });
+      } catch (error) {
+        results.push({
+          id,
+          found: false,
+          error: `\u8BFB\u53D6\u5931\u8D25: ${error}`
+        });
+      }
+    }
+    const successCount = results.filter((r) => r.found).length;
+    const totalLength = results.reduce((sum, r) => {
+      var _a;
+      return sum + (((_a = r.content) == null ? void 0 : _a.length) || 0);
+    }, 0);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          mode,
+          stats: {
+            requested: idsToLoad.length,
+            found: successCount,
+            totalChars: totalLength,
+            estimatedTokens: Math.ceil(totalLength / 4)
+          },
+          standards: results
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u83B7\u53D6\u89C4\u8303\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+function listAvailableStandards() {
+  ensureCache();
+  return Array.from(standardsCache.keys());
+}
+function ensureCache() {
+  if (standardsCache) return;
+  standardsCache = /* @__PURE__ */ new Map();
+  const baseDir = findBaseDir();
+  for (const dir of STANDARD_DIRS) {
+    const fullDir = path10.join(baseDir, dir);
+    if (!fs11.existsSync(fullDir)) continue;
+    scanDirectory(fullDir, standardsCache);
+  }
+}
+function findBaseDir() {
+  const possiblePaths = [
+    process.cwd(),
+    path10.join(process.cwd(), ".."),
+    path10.join(__dirname, "..", "..", "..")
+  ];
+  for (const p of possiblePaths) {
+    if (fs11.existsSync(path10.join(p, "standards"))) {
+      return p;
+    }
+  }
+  return process.cwd();
+}
+function scanDirectory(dir, cache) {
+  const items = fs11.readdirSync(dir);
+  for (const item of items) {
+    const fullPath = path10.join(dir, item);
+    const stat = fs11.statSync(fullPath);
+    if (stat.isDirectory()) {
+      scanDirectory(fullPath, cache);
+    } else if (item.endsWith(".md")) {
+      const id = path10.basename(item, ".md");
+      cache.set(id, fullPath);
+    }
+  }
+}
+function formatContent(content, mode) {
+  switch (mode) {
+    case "summary":
+      return extractSummary(content);
+    case "key-rules":
+      return extractKeyRules(content);
+    case "full":
+      return content;
+    default:
+      return content;
+  }
+}
+function extractSummary(content) {
+  const lines = content.split("\n");
+  const summaryLines = [];
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  if (titleMatch) {
+    summaryLines.push(`# ${titleMatch[1]}`);
+  }
+  let foundDescription = false;
+  for (const line of lines) {
+    if (line.startsWith("#") || line.trim() === "") continue;
+    if (line.startsWith(">")) {
+      summaryLines.push(line);
+      foundDescription = true;
+      break;
+    }
+    if (line.startsWith("-") || line.startsWith("*")) continue;
+    summaryLines.push(line);
+    foundDescription = true;
+    break;
+  }
+  const sectionHeaders = lines.filter((l) => l.match(/^##\s+/)).slice(0, 5);
+  if (sectionHeaders.length > 0) {
+    summaryLines.push("\n**\u4E3B\u8981\u7AE0\u8282**:");
+    summaryLines.push(...sectionHeaders.map((h) => `- ${h.replace(/^##\s+/, "")}`));
+  }
+  return summaryLines.join("\n");
+}
+function extractKeyRules(content) {
+  const lines = content.split("\n");
+  const keyRulesLines = [];
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  if (titleMatch) {
+    keyRulesLines.push(`# ${titleMatch[1]}`);
+  }
+  const keyPatterns = [
+    /强制|必须|禁止|规则|核心|关键|重要/,
+    /MUST|REQUIRED|SHOULD|必选|核心原则/,
+    /✅|❌|⚠️/
+  ];
+  let inKeySection = false;
+  let sectionDepth = 0;
+  let lineCount = 0;
+  const maxLines = 80;
+  for (const line of lines) {
+    const headerMatch = line.match(/^(#{2,3})\s+(.+)$/);
+    if (headerMatch) {
+      const depth = headerMatch[1].length;
+      const title = headerMatch[2];
+      inKeySection = keyPatterns.some((p) => p.test(title));
+      sectionDepth = depth;
+      if (inKeySection) {
+        keyRulesLines.push("");
+        keyRulesLines.push(line);
+        lineCount++;
+      }
+      continue;
+    }
+    if (inKeySection && lineCount < maxLines) {
+      if (line.match(/^#{2}\s+/) && sectionDepth >= 2) {
+        inKeySection = false;
+        continue;
+      }
+      keyRulesLines.push(line);
+      lineCount++;
+    }
+    if (!inKeySection && lineCount < maxLines) {
+      if (line.includes("\u2705") || line.includes("\u274C") || line.includes("\u26A0\uFE0F")) {
+        keyRulesLines.push(line);
+        lineCount++;
+      }
+    }
+  }
+  if (keyRulesLines.length < 20) {
+    const codeBlockMatch = content.match(/```[\s\S]{50,500}?```/);
+    if (codeBlockMatch) {
+      keyRulesLines.push("\n**\u793A\u4F8B**:");
+      keyRulesLines.push(codeBlockMatch[0]);
+    }
+  }
+  return keyRulesLines.join("\n").trim() || extractSummary(content);
+}
+
+// src/core/mappings/scenarioMappings.ts
+var SCENARIO_STANDARDS = {
+  // ========== Vue 相关场景 ==========
+  "vue3-component": ["vue3-composition", "typescript-strict"],
+  "vue3-form": ["vue3-composition", "element-plus", "form-validation"],
+  "vue3-table": ["vue3-composition", "element-plus", "pagination"],
+  "pinia-store": ["pinia-store", "typescript-strict"],
+  "composable": ["vue3-composition", "composable-patterns"],
+  // ========== API 相关 ==========
+  "api-call": ["axios-interceptor", "error-handling", "typescript-strict"],
+  "api-design": ["api-design", "restful-patterns"],
+  // ========== 国际化 ==========
+  "i18n": ["i18n", "vue-i18n"],
+  // ========== 测试 ==========
+  "unit-test": ["vitest-guide", "testing-patterns"],
+  // ========== 特殊场景 ==========
+  "logicflow": ["logicflow", "vue3-composition"],
+  "permission": ["permission-design", "route-guard"],
+  "performance": ["performance-optimization", "lazy-loading"]
+};
+var FILETYPE_STANDARDS = {
+  "vue": ["vue3-composition"],
+  "ts": ["typescript-strict"],
+  "tsx": ["react-hooks", "typescript-strict"],
+  "dart": ["dart-style", "flutter-bloc"]
+};
+var IMPORT_STANDARDS = {
+  "vue": ["vue3-composition"],
+  "element-plus": ["element-plus"],
+  "pinia": ["pinia-store"],
+  "axios": ["axios-interceptor"],
+  "vue-i18n": ["i18n"],
+  "@logicflow/core": ["logicflow"],
+  "vitest": ["vitest-guide"]
+};
+function getStandardsForScenario(scenario) {
+  return SCENARIO_STANDARDS[scenario] || [];
+}
+function getStandardsForFileType(fileType) {
+  return FILETYPE_STANDARDS[fileType] || [];
+}
+function getStandardsForImport(importName) {
+  const normalizedImport = importName.startsWith("@") ? importName.split("/").slice(0, 2).join("/") : importName.split("/")[0];
+  return IMPORT_STANDARDS[normalizedImport] || [];
+}
+function listAvailableScenarios() {
+  return Object.keys(SCENARIO_STANDARDS);
+}
+function suggestStandards(options) {
+  const suggestions = [];
+  if (options.scenario) {
+    suggestions.push(...getStandardsForScenario(options.scenario));
+  }
+  if (options.fileType) {
+    suggestions.push(...getStandardsForFileType(options.fileType));
+  }
+  if (options.imports) {
+    for (const imp of options.imports) {
+      suggestions.push(...getStandardsForImport(imp));
+    }
+  }
+  return [...new Set(suggestions)];
+}
+
+// src/tools/queryMappings.ts
+async function queryMappings(args) {
+  const logger3 = new ConsoleLogger();
+  try {
+    if (args.listAll) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            description: "\u573A\u666F-\u89C4\u8303\u6620\u5C04\u8868\uFF0CAI \u53EF\u53C2\u8003\u8FD9\u4E9B\u6620\u5C04\u81EA\u884C\u51B3\u5B9A\u4F7F\u7528\u54EA\u4E9B\u89C4\u8303",
+            mappings: {
+              scenarios: SCENARIO_STANDARDS,
+              fileTypes: FILETYPE_STANDARDS,
+              imports: IMPORT_STANDARDS
+            },
+            availableScenarios: listAvailableScenarios()
+          }, null, 2)
+        }]
+      };
+    }
+    const result = {
+      success: true,
+      query: {},
+      suggestions: []
+    };
+    if (args.scenario) {
+      result.query.scenario = args.scenario;
+      result.scenarioStandards = SCENARIO_STANDARDS[args.scenario] || [];
+    }
+    if (args.fileType) {
+      result.query.fileType = args.fileType;
+      result.fileTypeStandards = FILETYPE_STANDARDS[args.fileType] || [];
+    }
+    if (args.imports && args.imports.length > 0) {
+      result.query.imports = args.imports;
+      result.importStandards = {};
+      for (const imp of args.imports) {
+        const normalizedImport = imp.startsWith("@") ? imp.split("/").slice(0, 2).join("/") : imp.split("/")[0];
+        result.importStandards[imp] = IMPORT_STANDARDS[normalizedImport] || [];
+      }
+    }
+    result.suggestions = suggestStandards({
+      scenario: args.scenario,
+      fileType: args.fileType,
+      imports: args.imports
+    });
+    result.note = "AI \u53EF\u6839\u636E\u5177\u4F53\u60C5\u51B5\u9009\u62E9\u4F7F\u7528\u54EA\u4E9B\u89C4\u8303\uFF0C\u8FD9\u53EA\u662F\u5EFA\u8BAE\u5217\u8868";
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u67E5\u8BE2\u6620\u5C04\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+async function listScenarios() {
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        success: true,
+        scenarios: listAvailableScenarios(),
+        description: "AI \u53EF\u4F7F\u7528\u8FD9\u4E9B\u573A\u666F\u540D\u79F0\u8C03\u7528 use_preset \u6216 query_mappings"
+      }, null, 2)
+    }]
+  };
+}
+
+// src/core/templates/discovery.ts
+import * as fs12 from "fs";
+import * as path11 from "path";
+var TEMPLATES_DIR = path11.resolve(
+  path11.dirname(new URL(import.meta.url).pathname),
+  "../../../../templates"
+);
+var templatesCache = null;
+function ensureCache2() {
+  if (templatesCache) return;
+  templatesCache = /* @__PURE__ */ new Map();
+  scanTemplates(TEMPLATES_DIR, "");
+}
+function scanTemplates(dir, prefix) {
+  if (!fs12.existsSync(dir)) return;
+  const entries = fs12.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const fullPath = path11.join(dir, entry.name);
+    const templateId = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const configPath = path11.join(fullPath, "_CONFIG.md");
+    if (fs12.existsSync(configPath)) {
+      const metadata = parseConfigMd(configPath, templateId, fullPath);
+      if (metadata) {
+        templatesCache.set(templateId, metadata);
+      }
+    }
+    scanTemplates(fullPath, templateId);
+  }
+}
+function parseConfigMd(configPath, templateId, templateDir) {
+  try {
+    const content = fs12.readFileSync(configPath, "utf-8");
+    const titleMatch = content.match(/^#\s+(.+)$/m);
+    const name = titleMatch ? titleMatch[1].trim() : templateId;
+    const descMatch = content.match(/^>\s*(.+)$/m);
+    const description = descMatch ? descMatch[1].trim() : "";
+    const frameworkMatch = content.match(/\*\*适用框架\*\*:\s*(.+)/i);
+    const frameworks = frameworkMatch ? frameworkMatch[1].split(/[,\/+]/).map((f) => f.trim()) : [];
+    const type = inferTemplateType(templateId, name);
+    const files = getTemplateFiles(templateDir);
+    const dependencies = extractDependencies(content);
+    const pathMatch = content.match(/复制到.*?`([^`]+)`/i);
+    const suggestedPath = pathMatch ? pathMatch[1] : void 0;
+    return {
+      id: templateId,
+      name,
+      description,
+      frameworks,
+      type,
+      files,
+      dependencies,
+      configFile: "_CONFIG.md",
+      suggestedPath,
+      keywords: extractKeywords(name, description, frameworks)
+    };
+  } catch (error) {
+    console.error(`\u89E3\u6790\u6A21\u677F\u914D\u7F6E\u5931\u8D25: ${configPath}`, error);
+    return null;
+  }
+}
+function inferTemplateType(templateId, name) {
+  const lower = (templateId + name).toLowerCase();
+  if (lower.includes("api") || lower.includes("request") || lower.includes("axios")) {
+    return "api-layer";
+  }
+  if (lower.includes("component")) return "component";
+  if (lower.includes("store") || lower.includes("pinia")) return "store";
+  if (lower.includes("composable") || lower.includes("hook")) return "composable";
+  if (lower.includes("config")) return "config";
+  if (lower.includes("type")) return "types";
+  return "other";
+}
+function getTemplateFiles(dir, prefix = "") {
+  const files = [];
+  const entries = fs12.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.name === "_CONFIG.md" || entry.name === "_template.json") {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      files.push(...getTemplateFiles(path11.join(dir, entry.name), relativePath));
+    } else {
+      files.push(relativePath);
+    }
+  }
+  return files;
+}
+function extractDependencies(content) {
+  const depsMatch = content.match(/"dependencies":\s*\{([^}]+)\}/);
+  if (!depsMatch) return void 0;
+  const deps = {};
+  const pairs = depsMatch[1].matchAll(/"([^"]+)":\s*"([^"]+)"/g);
+  for (const match of pairs) {
+    deps[match[1]] = match[2];
+  }
+  return Object.keys(deps).length > 0 ? deps : void 0;
+}
+function extractKeywords(name, description, frameworks) {
+  const text = `${name} ${description}`.toLowerCase();
+  const keywords = new Set(frameworks.map((f) => f.toLowerCase()));
+  const commonKeywords = ["axios", "api", "mock", "request", "http", "fetch", "store", "pinia", "vuex"];
+  for (const kw of commonKeywords) {
+    if (text.includes(kw)) keywords.add(kw);
+  }
+  return Array.from(keywords);
+}
+function listAllTemplates() {
+  ensureCache2();
+  const result = [];
+  for (const [id, metadata] of templatesCache) {
+    result.push({
+      id,
+      name: metadata.name,
+      description: metadata.description,
+      frameworks: metadata.frameworks,
+      type: metadata.type,
+      fileCount: metadata.files.length,
+      suggestedPath: metadata.suggestedPath
+    });
+  }
+  return result;
+}
+function listTemplatesByType(type) {
+  return listAllTemplates().filter((t) => t.type === type);
+}
+function listTemplatesByFramework(framework) {
+  const lower = framework.toLowerCase();
+  return listAllTemplates().filter(
+    (t) => t.frameworks.some((f) => f.toLowerCase().includes(lower))
+  );
+}
+function getTemplateById(templateId, includeFiles = false) {
+  ensureCache2();
+  const metadata = templatesCache.get(templateId);
+  if (!metadata) return null;
+  const templateDir = path11.join(TEMPLATES_DIR, templateId);
+  const configPath = path11.join(templateDir, "_CONFIG.md");
+  const configGuide = fs12.existsSync(configPath) ? fs12.readFileSync(configPath, "utf-8") : "";
+  const result = {
+    metadata,
+    configGuide
+  };
+  if (includeFiles) {
+    result.files = [];
+    for (const filePath of metadata.files) {
+      const fullPath = path11.join(templateDir, filePath);
+      if (fs12.existsSync(fullPath)) {
+        result.files.push({
+          path: filePath,
+          content: fs12.readFileSync(fullPath, "utf-8"),
+          isConfig: filePath.startsWith("_")
+        });
+      }
+    }
+  }
+  return result;
+}
+function getTemplateDir(templateId) {
+  ensureCache2();
+  if (!templatesCache.has(templateId)) return null;
+  return path11.join(TEMPLATES_DIR, templateId);
+}
+function searchTemplates(query) {
+  const lower = query.toLowerCase();
+  return listAllTemplates().filter(
+    (t) => t.id.toLowerCase().includes(lower) || t.name.toLowerCase().includes(lower) || t.description.toLowerCase().includes(lower) || t.frameworks.some((f) => f.toLowerCase().includes(lower))
+  );
+}
+
+// src/tools/listTemplates.ts
+async function listTemplates(args) {
+  const logger3 = new ConsoleLogger();
+  try {
+    let templates;
+    if (args.search) {
+      templates = searchTemplates(args.search);
+    } else if (args.type) {
+      templates = listTemplatesByType(args.type);
+    } else if (args.framework) {
+      templates = listTemplatesByFramework(args.framework);
+    } else {
+      templates = listAllTemplates();
+    }
+    const grouped = {};
+    for (const t of templates) {
+      if (!grouped[t.type]) grouped[t.type] = [];
+      grouped[t.type].push(t);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          total: templates.length,
+          templates,
+          byType: grouped,
+          usage: {
+            getDetails: 'get_template({ id: "\u6A21\u677FID" })',
+            getWithFiles: 'get_template({ id: "\u6A21\u677FID", includeFiles: true })',
+            note: "AI \u53EF\u76F4\u63A5\u8BFB\u53D6\u6A21\u677F\u6587\u4EF6\u5E76\u590D\u5236\u5230\u76EE\u6807\u9879\u76EE"
+          }
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u5217\u51FA\u6A21\u677F\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// src/tools/getTemplate.ts
+async function getTemplate(args) {
+  var _a;
+  const logger3 = new ConsoleLogger();
+  try {
+    const result = getTemplateById(args.id, (_a = args.includeFiles) != null ? _a : false);
+    if (!result) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: `\u6A21\u677F "${args.id}" \u4E0D\u5B58\u5728`,
+            hint: "\u4F7F\u7528 list_templates \u67E5\u770B\u53EF\u7528\u6A21\u677F"
+          }, null, 2)
+        }]
+      };
+    }
+    if (args.files && result.files) {
+      result.files = result.files.filter(
+        (f) => args.files.some(
+          (requested) => f.path === requested || f.path.endsWith(requested)
+        )
+      );
+    }
+    const templateDir = getTemplateDir(args.id);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          template: {
+            ...result,
+            absolutePath: templateDir
+          },
+          aiGuidance: {
+            step1: "\u9605\u8BFB configGuide \u4E86\u89E3\u914D\u7F6E\u8981\u6C42",
+            step2: "\u6839\u636E\u76EE\u6807\u9879\u76EE\u60C5\u51B5\u51B3\u5B9A\u5982\u4F55\u4FEE\u6539\u6A21\u677F",
+            step3: "\u5C06\u6587\u4EF6\u590D\u5236\u5230\u76EE\u6807\u9879\u76EE\u5E76\u9002\u914D",
+            note: "\u6A21\u677F\u6587\u4EF6\u53EF\u80FD\u9700\u8981\u6839\u636E\u9879\u76EE\u5B9E\u9645\u60C5\u51B5\u8C03\u6574\uFF08\u5982 UI \u6846\u67B6\u3001\u540E\u7AEF\u54CD\u5E94\u683C\u5F0F\u7B49\uFF09"
+          }
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    logger3.error(`\u83B7\u53D6\u6A21\u677F\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// src/core/errors.ts
+var ERROR_MESSAGES = {
+  [1e3 /* UNKNOWN */]: "\u672A\u77E5\u9519\u8BEF",
+  [1001 /* INVALID_PARAMETER */]: "\u53C2\u6570\u65E0\u6548",
+  [1002 /* NOT_FOUND */]: "\u8D44\u6E90\u672A\u627E\u5230",
+  [1003 /* PERMISSION_DENIED */]: "\u6743\u9650\u4E0D\u8DB3",
+  [2001 /* PROJECT_NOT_FOUND */]: "\u9879\u76EE\u76EE\u5F55\u4E0D\u5B58\u5728",
+  [2002 /* PROJECT_PARSE_ERROR */]: "\u9879\u76EE\u89E3\u6790\u5931\u8D25",
+  [2003 /* CONFIG_READ_ERROR */]: "\u914D\u7F6E\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25",
+  [3001 /* STANDARD_NOT_FOUND */]: "\u89C4\u8303\u672A\u627E\u5230",
+  [3002 /* STANDARD_LOAD_ERROR */]: "\u89C4\u8303\u52A0\u8F7D\u5931\u8D25",
+  [3003 /* PRESET_NOT_FOUND */]: "\u9884\u8BBE\u672A\u627E\u5230",
+  [4001 /* TEMPLATE_NOT_FOUND */]: "\u6A21\u677F\u672A\u627E\u5230",
+  [4002 /* TEMPLATE_PARSE_ERROR */]: "\u6A21\u677F\u89E3\u6790\u5931\u8D25",
+  [5001 /* AGENT_NOT_FOUND */]: "Agent \u672A\u627E\u5230",
+  [5002 /* AGENT_LOAD_ERROR */]: "Agent \u52A0\u8F7D\u5931\u8D25",
+  [6001 /* CONFIG_GENERATE_ERROR */]: "\u914D\u7F6E\u751F\u6210\u5931\u8D25",
+  [6002 /* FILE_WRITE_ERROR */]: "\u6587\u4EF6\u5199\u5165\u5931\u8D25"
+};
+var MCPError = class _MCPError extends Error {
+  constructor(code, message, options) {
+    const defaultMessage = ERROR_MESSAGES[code] || "\u672A\u77E5\u9519\u8BEF";
+    super(message || defaultMessage);
+    this.name = "MCPError";
+    this.code = code;
+    this.cause = options == null ? void 0 : options.cause;
+    this.context = options == null ? void 0 : options.context;
+    Object.setPrototypeOf(this, _MCPError.prototype);
+  }
+  /**
+   * 转换为 JSON 格式（用于 MCP 响应）
+   */
+  toJSON() {
+    return {
+      error: true,
+      code: this.code,
+      message: this.message,
+      ...this.context && { context: this.context }
+    };
+  }
+  /**
+   * 转换为 MCP 响应格式
+   */
+  toResponse() {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(this.toJSON(), null, 2)
+      }]
+    };
+  }
+};
+function errorResponse(error) {
+  if (error instanceof MCPError) {
+    return error.toResponse();
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        error: true,
+        code: 1e3 /* UNKNOWN */,
+        message
+      }, null, 2)
+    }]
+  };
+}
+
+// src/core/logger.ts
+var LOG_LEVEL_NAMES = {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR",
+  [4 /* SILENT */]: "SILENT"
+};
+var globalConfig = {
+  level: process.env.DEBUG ? 0 /* DEBUG */ : 1 /* INFO */,
+  timestamp: false,
+  prefix: "[MCP]"
+};
+var Logger = class _Logger {
+  constructor(name, config) {
+    this.name = name || "";
+    this.config = { ...globalConfig, ...config };
+  }
+  /**
+   * 格式化日志消息
+   */
+  format(level, message, ...args) {
+    const parts = [];
+    if (this.config.timestamp) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    parts.push(this.config.prefix);
+    if (this.name) {
+      parts.push(`[${this.name}]`);
+    }
+    parts.push(`[${LOG_LEVEL_NAMES[level]}]`);
+    parts.push(message);
+    if (args.length > 0) {
+      const formatted = args.map((arg) => {
+        if (typeof arg === "object") {
+          try {
+            return JSON.stringify(arg, null, 2);
+          } catch {
+            return String(arg);
+          }
+        }
+        return String(arg);
+      });
+      parts.push(...formatted);
+    }
+    return parts.join(" ");
+  }
+  /**
+   * 检查日志级别是否应该输出
+   */
+  shouldLog(level) {
+    return level >= this.config.level;
+  }
+  /**
+   * 调试日志
+   */
+  debug(message, ...args) {
+    if (this.shouldLog(0 /* DEBUG */)) {
+      console.error(this.format(0 /* DEBUG */, message, ...args));
+    }
+  }
+  /**
+   * 信息日志
+   */
+  info(message, ...args) {
+    if (this.shouldLog(1 /* INFO */)) {
+      console.error(this.format(1 /* INFO */, message, ...args));
+    }
+  }
+  /**
+   * 简化的 log 方法（等同于 info）
+   */
+  log(message, ...args) {
+    this.info(message, ...args);
+  }
+  /**
+   * 警告日志
+   */
+  warn(message, ...args) {
+    if (this.shouldLog(2 /* WARN */)) {
+      console.error(this.format(2 /* WARN */, message, ...args));
+    }
+  }
+  /**
+   * 错误日志
+   */
+  error(message, ...args) {
+    if (this.shouldLog(3 /* ERROR */)) {
+      console.error(this.format(3 /* ERROR */, message, ...args));
+    }
+  }
+  /**
+   * 创建子 Logger
+   */
+  child(name) {
+    const childName = this.name ? `${this.name}:${name}` : name;
+    return new _Logger(childName, this.config);
+  }
+};
+var logger = new Logger();
+function createLogger(name) {
+  return new Logger(name);
+}
+
+// src/index.ts
+var SERVER_VERSION = "2.2.0";
+var logger2 = createLogger("Server");
+var CopilotPromptsMCPServer = class {
+  constructor() {
+    this.standardsManager = new StandardsManager();
+    this.codeValidator = new CodeValidator();
+    this.server = new Server(
+      {
+        name: "mta",
+        version: SERVER_VERSION
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {}
+        }
+      }
+    );
+    this.setupToolHandlers();
+    this.setupResourceHandlers();
+    this.setupErrorHandlers();
+  }
+  /**
+   * 设置错误处理器
+   */
+  setupErrorHandlers() {
+    this.server.onerror = (error) => {
+      logger2.error("MCP \u670D\u52A1\u5668\u9519\u8BEF", error);
+    };
+    process.on("SIGINT", async () => {
+      logger2.info("\u6536\u5230\u5173\u95ED\u4FE1\u53F7\uFF0C\u6B63\u5728\u5173\u95ED\u670D\u52A1\u5668...");
+      await this.server.close();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      logger2.info("\u6536\u5230\u7EC8\u6B62\u4FE1\u53F7\uFF0C\u6B63\u5728\u5173\u95ED\u670D\u52A1\u5668...");
+      await this.server.close();
+      process.exit(0);
+    });
+    process.on("uncaughtException", (error) => {
+      logger2.error("\u672A\u6355\u83B7\u7684\u5F02\u5E38:", error);
+      process.exit(1);
+    });
+    process.on("unhandledRejection", (reason, promise) => {
+      logger2.error("\u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD:", reason);
+      process.exit(1);
+    });
+  }
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "analyze_project",
+          description: "\u5206\u6790\u9879\u76EE\u7684\u6280\u672F\u6808\u3001\u6846\u67B6\u3001\u5DE5\u5177\u548C\u7279\u5F81\u3002\u81EA\u52A8\u68C0\u6D4B Vue\u3001React\u3001TypeScript \u7B49\u6280\u672F\u3002\u8DEF\u5F84\u53EF\u9009\uFF0C\u4E0D\u586B\u5219\u81EA\u52A8\u68C0\u6D4B\u5F53\u524D\u5DE5\u4F5C\u533A\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              projectPath: {
+                type: "string",
+                description: "\u9879\u76EE\u7684\u7EDD\u5BF9\u8DEF\u5F84\uFF08\u53EF\u9009\uFF0C\u4E0D\u586B\u5219\u4F7F\u7528\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09\uFF0C\u4F8B\u5982: /Users/username/projects/my-app"
+              }
+            }
+          }
+        },
+        {
+          name: "auto_setup",
+          description: "\u{1F3AF} \u4E00\u952E\u81EA\u52A8\u914D\u7F6E MCP \u670D\u52A1\u5668\u548C\u9879\u76EE\u89C4\u8303\u3002\u81EA\u52A8\u521B\u5EFA .vscode/mcp.json\u3001settings.json\u3001extensions.json\uFF0C\u5E76\u5206\u6790\u9879\u76EE\u751F\u6210 .github/copilot-instructions.md \u914D\u7F6E\u6587\u4EF6\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              workspacePath: {
+                type: "string",
+                description: "\u5DE5\u4F5C\u533A\u8DEF\u5F84\uFF08\u53EF\u9009\uFF0C\u4E0D\u586B\u5219\u4F7F\u7528\u5F53\u524D\u76EE\u5F55\uFF09"
+              },
+              generateInstructions: {
+                type: "boolean",
+                description: "\u662F\u5426\u81EA\u52A8\u751F\u6210 copilot-instructions.md\uFF08\u9ED8\u8BA4 true\uFF09",
+                default: true
+              }
+            }
+          }
+        },
+        {
+          name: "health_check",
+          description: "\u{1F3E5} \u68C0\u67E5 MCP \u670D\u52A1\u5668\u5065\u5EB7\u72B6\u6001\uFF0C\u8BCA\u65AD\u914D\u7F6E\u95EE\u9898\u3002\u8FD4\u56DE\u8BE6\u7EC6\u7684\u5065\u5EB7\u62A5\u544A\u548C\u4FEE\u590D\u5EFA\u8BAE\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              workspacePath: {
+                type: "string",
+                description: "\u5DE5\u4F5C\u533A\u8DEF\u5F84\uFF08\u53EF\u9009\uFF09"
+              },
+              verbose: {
+                type: "boolean",
+                description: "\u662F\u5426\u663E\u793A\u8BE6\u7EC6\u4FE1\u606F\uFF08\u9ED8\u8BA4 false\uFF09"
+              }
+            }
+          }
+        },
+        {
+          name: "get_smart_standards",
+          description: "\u{1F9E0} \u96F6\u53C2\u6570\u667A\u80FD\u89C4\u8303\u63A8\u8350\u3002\u81EA\u52A8\u68C0\u6D4B\u5F53\u524D\u6587\u4EF6\u7C7B\u578B\u3001\u5BFC\u5165\u3001\u573A\u666F\uFF0C\u63A8\u8350\u6700\u76F8\u5173\u7684\u7F16\u7801\u89C4\u8303\u3002\u6BD4\u624B\u52A8\u6307\u5B9A\u53C2\u6570\u66F4\u7B80\u5355\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              currentFile: {
+                type: "string",
+                description: "\u5F53\u524D\u7F16\u8F91\u7684\u6587\u4EF6\u8DEF\u5F84\uFF08\u53EF\u9009\uFF09"
+              },
+              fileContent: {
+                type: "string",
+                description: "\u6587\u4EF6\u5185\u5BB9\uFF08\u53EF\u9009\uFF0C\u7528\u4E8E\u5206\u6790\u5BFC\u5165\u548C\u573A\u666F\uFF09"
+              }
+            }
+          }
+        },
+        {
+          name: "use_preset",
+          description: "\u26A1 \u4F7F\u7528\u9884\u8BBE\u573A\u666F\u5FEB\u6377\u83B7\u53D6\u89C4\u8303\u3002\u652F\u6301 vue3-component\u3001vue3-form\u3001pinia-store\u3001api-call \u7B49\u5E38\u89C1\u573A\u666F\uFF0C\u4E00\u952E\u83B7\u53D6\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              preset: {
+                type: "string",
+                enum: ["vue3-component", "vue3-form", "vue3-table", "pinia-store", "api-call", "typescript-strict", "i18n", "composable"],
+                description: "\u9884\u8BBE\u573A\u666F ID"
+              },
+              customImports: {
+                type: "array",
+                items: { type: "string" },
+                description: "\u989D\u5916\u7684\u5BFC\u5165\uFF08\u53EF\u9009\uFF09"
+              }
+            },
+            required: ["preset"]
+          }
+        },
+        {
+          name: "list_presets",
+          description: "\u{1F4CB} \u5217\u51FA\u6240\u6709\u53EF\u7528\u7684\u9884\u8BBE\u573A\u666F\u53CA\u5176\u8BF4\u660E\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "match_agents",
+          description: "\u6839\u636E\u9879\u76EE\u7279\u5F81\u667A\u80FD\u5339\u914D\u6700\u5408\u9002\u7684 Copilot Agents\u3002\u4F7F\u7528\u52A0\u6743\u8BC4\u5206\u7B97\u6CD5\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              projectFeatures: {
+                type: "object",
+                description: "\u9879\u76EE\u7279\u5F81\u5BF9\u8C61\uFF08\u4ECE analyze_project \u83B7\u53D6\uFF09",
+                properties: {
+                  frameworks: { type: "array", items: { type: "string" } },
+                  languages: { type: "array", items: { type: "string" } },
+                  tools: { type: "array", items: { type: "string" } },
+                  keywords: { type: "array", items: { type: "string" } },
+                  projectType: { type: "string" }
+                },
+                required: ["frameworks", "languages", "tools", "keywords", "projectType"]
+              },
+              limit: {
+                type: "number",
+                description: "\u8FD4\u56DE\u7684\u6700\u5927 Agent \u6570\u91CF\uFF08\u9ED8\u8BA4 10\uFF09",
+                default: 10
+              }
+            },
+            required: ["projectFeatures"]
+          }
+        },
+        {
+          name: "list_available_agents",
+          description: "\u83B7\u53D6\u6240\u6709\u53EF\u7528\u7684 Copilot Agents \u5217\u8868\uFF0C\u5305\u62EC\u540D\u79F0\u3001\u63CF\u8FF0\u3001\u8DEF\u5F84\u7B49\u4FE1\u606F\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "generate_config",
+          description: "\u4E3A\u9879\u76EE\u751F\u6210 Copilot \u914D\u7F6E\u6587\u4EF6\uFF08.github/copilot-instructions.md\uFF09\u3002\u53EF\u4EE5\u81EA\u52A8\u5339\u914D\u6216\u624B\u52A8\u6307\u5B9A Agents\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              projectPath: {
+                type: "string",
+                description: "\u9879\u76EE\u7684\u7EDD\u5BF9\u8DEF\u5F84"
+              },
+              agentIds: {
+                type: "array",
+                items: { type: "string" },
+                description: "\u8981\u5E94\u7528\u7684 Agent ID \u5217\u8868\uFF08\u53EF\u9009\uFF0C\u5982\u4E0D\u63D0\u4F9B\u5219\u81EA\u52A8\u5339\u914D\uFF09"
+              },
+              autoMatch: {
+                type: "boolean",
+                description: "\u662F\u5426\u81EA\u52A8\u5339\u914D Agents\uFF08\u9ED8\u8BA4 true\uFF09",
+                default: true
+              },
+              updateMode: {
+                type: "string",
+                enum: ["merge", "overwrite"],
+                description: "\u66F4\u65B0\u6A21\u5F0F\uFF1Amerge-\u4FDD\u7559\u81EA\u5B9A\u4E49\u5185\u5BB9\uFF08\u9ED8\u8BA4\uFF09\uFF0Coverwrite-\u5B8C\u5168\u8986\u76D6",
+                default: "merge"
+              },
+              configId: {
+                type: "string",
+                description: "\u914D\u7F6E\u65B9\u6848ID\uFF08\u5982 strict\uFF09\uFF0C\u4F1A\u52A0\u8F7D\u5BF9\u5E94\u7684\u8BE6\u7EC6\u89C4\u5219"
+              }
+            },
+            required: ["projectPath"]
+          }
+        },
+        {
+          name: "get_compact_standards",
+          description: "\u{1F680} Token \u4F18\u5316\u7248\u89C4\u8303\u83B7\u53D6\u3002\u652F\u6301\u4E09\u79CD\u6A21\u5F0F\uFF1Asummary(~500 tokens)\u4EC5\u8FD4\u56DE\u89C4\u8303\u5217\u8868\u3001key-rules(~2000 tokens)\u8FD4\u56DE\u5173\u952E\u89C4\u5219\u6458\u8981\u3001full(\u5B8C\u6574\u5185\u5BB9)\u3002\u9ED8\u8BA4 key-rules \u6A21\u5F0F\uFF0C\u6BD4\u5B8C\u6574\u52A0\u8F7D\u8282\u7701 80%+ token\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              currentFile: {
+                type: "string",
+                description: "\u5F53\u524D\u6587\u4EF6\u8DEF\u5F84\uFF08\u53EF\u9009\uFF09"
+              },
+              fileContent: {
+                type: "string",
+                description: "\u6587\u4EF6\u5185\u5BB9\uFF08\u53EF\u9009\uFF0C\u7528\u4E8E\u5206\u6790\uFF09"
+              },
+              scenario: {
+                type: "string",
+                description: "\u5F00\u53D1\u573A\u666F\uFF08\u53EF\u9009\uFF09"
+              },
+              mode: {
+                type: "string",
+                enum: ["summary", "key-rules", "full"],
+                description: "\u8FD4\u56DE\u6A21\u5F0F\uFF1Asummary(~500 tokens)\u3001key-rules(~2000 tokens\uFF0C\u9ED8\u8BA4)\u3001full(\u5B8C\u6574\u5185\u5BB9)",
+                default: "key-rules"
+              }
+            }
+          }
+        },
+        {
+          name: "get_relevant_standards",
+          description: "\u6839\u636E\u5F53\u524D\u5F00\u53D1\u4E0A\u4E0B\u6587\uFF0C\u83B7\u53D6\u76F8\u5173\u7684\u7F16\u7801\u89C4\u8303\uFF08\u5B8C\u6574\u5185\u5BB9\uFF09\u3002\u5982\u9700\u8282\u7701 token\uFF0C\u8BF7\u4F7F\u7528 get_compact_standards\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              fileType: {
+                type: "string",
+                description: "\u6587\u4EF6\u7C7B\u578B\uFF08\u5982 vue, ts, tsx, js\uFF09"
+              },
+              imports: {
+                type: "array",
+                items: { type: "string" },
+                description: '\u6587\u4EF6\u4E2D\u7684 import \u8BED\u53E5\uFF08\u5982 ["vue", "pinia", "element-plus"]\uFF09\u3002\u5982\u679C\u672A\u63D0\u4F9B\u4E14\u63D0\u4F9B\u4E86 fileContent\uFF0C\u5C06\u81EA\u52A8\u68C0\u6D4B\u3002'
+              },
+              scenario: {
+                type: "string",
+                description: '\u5F00\u53D1\u573A\u666F\u63CF\u8FF0\uFF08\u5982 "\u521B\u5EFA\u8868\u5355\u7EC4\u4EF6", "API \u8C03\u7528", "\u72B6\u6001\u7BA1\u7406"\uFF09'
+              },
+              fileContent: {
+                type: "string",
+                description: "\u6587\u4EF6\u5185\u5BB9\uFF08\u53EF\u9009\uFF09\u3002\u63D0\u4F9B\u540E\u53EF\u81EA\u52A8\u68C0\u6D4B imports \u5E76\u6839\u636E\u5173\u952E\u8BCD\u667A\u80FD\u5339\u914D\u89C4\u8303\u3002"
+              }
+            }
+          }
+        },
+        {
+          name: "get_standards_stats",
+          description: "\u83B7\u53D6\u89C4\u8303\u7CFB\u7EDF\u7684\u4F7F\u7528\u7EDF\u8BA1\u548C\u6027\u80FD\u6307\u6807\u3002\u7528\u4E8E\u4E86\u89E3\u6700\u5E38\u7528\u7684\u89C4\u8303\u7EC4\u5408\u3001\u7F13\u5B58\u547D\u4E2D\u7387\u3001Token \u8282\u7701\u60C5\u51B5\u7B49\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              includeCache: {
+                type: "boolean",
+                description: "\u662F\u5426\u5305\u542B\u7F13\u5B58\u8BE6\u7EC6\u4FE1\u606F\uFF08\u9ED8\u8BA4 false\uFF09"
+              }
+            }
+          }
+        },
+        {
+          name: "get_standard_by_id",
+          description: "\u{1F4D6} \u6309 ID \u76F4\u63A5\u83B7\u53D6\u89C4\u8303\u3002AI \u77E5\u9053\u9700\u8981\u4EC0\u4E48\u89C4\u8303\u65F6\uFF0C\u76F4\u63A5\u6309 ID \u83B7\u53D6\uFF0C\u6700\u7B80\u6D01\u9AD8\u6548\u3002\u652F\u6301\u4E09\u79CD\u6A21\u5F0F\uFF1Asummary(\u6458\u8981)\u3001key-rules(\u5173\u952E\u89C4\u5219\uFF0C\u9ED8\u8BA4)\u3001full(\u5B8C\u6574\u5185\u5BB9)\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string",
+                description: "\u89C4\u8303 ID\uFF08\u5982 vue3-composition, element-plus, pinia\uFF09"
+              },
+              ids: {
+                type: "array",
+                items: { type: "string" },
+                description: "\u591A\u4E2A\u89C4\u8303 ID\uFF0C\u6279\u91CF\u83B7\u53D6"
+              },
+              mode: {
+                type: "string",
+                enum: ["summary", "key-rules", "full"],
+                description: "\u52A0\u8F7D\u6A21\u5F0F\uFF1Asummary(\u6458\u8981)\u3001key-rules(\u5173\u952E\u89C4\u5219\uFF0C\u9ED8\u8BA4)\u3001full(\u5B8C\u6574\u5185\u5BB9)",
+                default: "key-rules"
+              }
+            }
+          }
+        },
+        {
+          name: "query_mappings",
+          description: '\u{1F5FA}\uFE0F \u67E5\u8BE2\u573A\u666F-\u89C4\u8303\u6620\u5C04\u5173\u7CFB\u3002\u63D0\u4F9B\u6620\u5C04\u4FE1\u606F\u7ED9 AI \u53C2\u8003\uFF0CAI \u81EA\u5DF1\u51B3\u5B9A\u4F7F\u7528\u54EA\u4E9B\u89C4\u8303\u3002\u4E0D\u505A"\u667A\u80FD\u63A8\u8350"\uFF0C\u53EA\u63D0\u4F9B\u6570\u636E\u67E5\u8BE2\u3002',
+          inputSchema: {
+            type: "object",
+            properties: {
+              scenario: {
+                type: "string",
+                description: "\u573A\u666F\u540D\u79F0\uFF08\u5982 vue3-form, api-call, pinia-store\uFF09"
+              },
+              fileType: {
+                type: "string",
+                description: "\u6587\u4EF6\u7C7B\u578B\uFF08\u5982 vue, ts, tsx\uFF09"
+              },
+              imports: {
+                type: "array",
+                items: { type: "string" },
+                description: "\u5BFC\u5165\u7684\u5305\uFF08\u5982 element-plus, pinia\uFF09"
+              },
+              listAll: {
+                type: "boolean",
+                description: "\u5217\u51FA\u6240\u6709\u6620\u5C04\u5173\u7CFB"
+              }
+            }
+          }
+        },
+        {
+          name: "list_scenarios",
+          description: "\u{1F4CB} \u5217\u51FA\u6240\u6709\u53EF\u7528\u7684\u573A\u666F\u540D\u79F0\u3002AI \u53EF\u4F7F\u7528\u8FD9\u4E9B\u573A\u666F\u540D\u79F0\u8C03\u7528 use_preset \u6216 query_mappings\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "list_templates",
+          description: "\u{1F4E6} \u5217\u51FA\u53EF\u7528\u7684\u4EE3\u7801\u6A21\u677F\u3002\u6A21\u677F\u662F\u53EF\u590D\u7528\u7684\u4EE3\u7801\u7247\u6BB5\uFF0CAI \u53EF\u6839\u636E\u9700\u8981\u9009\u62E9\u5E76\u5E94\u7528\u5230\u76EE\u6807\u9879\u76EE\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string",
+                enum: ["api-layer", "component", "store", "composable", "config", "types", "other"],
+                description: "\u6309\u7C7B\u578B\u7B5B\u9009"
+              },
+              framework: {
+                type: "string",
+                description: "\u6309\u6846\u67B6\u7B5B\u9009\uFF08\u5982 vue, react\uFF09"
+              },
+              search: {
+                type: "string",
+                description: "\u641C\u7D22\u5173\u952E\u8BCD"
+              }
+            }
+          }
+        },
+        {
+          name: "get_template",
+          description: "\u{1F4C4} \u83B7\u53D6\u6A21\u677F\u8BE6\u60C5\u548C\u6587\u4EF6\u5185\u5BB9\u3002AI \u53EF\u6839\u636E\u914D\u7F6E\u8BF4\u660E\u81EA\u884C\u4FEE\u6539\u5E76\u5E94\u7528\u6A21\u677F\u3002",
+          inputSchema: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string",
+                description: "\u6A21\u677F ID\uFF08\u5982 vue/api-layer\uFF09"
+              },
+              includeFiles: {
+                type: "boolean",
+                description: "\u662F\u5426\u5305\u542B\u6587\u4EF6\u5185\u5BB9\uFF08\u9ED8\u8BA4 false\uFF0C\u53EA\u8FD4\u56DE\u914D\u7F6E\u8BF4\u660E\uFF09",
+                default: false
+              },
+              files: {
+                type: "array",
+                items: { type: "string" },
+                description: "\u6307\u5B9A\u8981\u83B7\u53D6\u7684\u6587\u4EF6\u5217\u8868\uFF08\u53EF\u9009\uFF09"
+              }
+            },
+            required: ["id"]
+          }
+        }
+      ]
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        const { name, arguments: args } = request.params;
+        logger2.debug(`\u8C03\u7528\u5DE5\u5177: ${name}`);
+        logger2.debug(`\u53C2\u6570:`, args);
+        switch (name) {
+          case "analyze_project":
+            return await analyzeProject(args);
+          case "auto_setup":
+            return await autoSetup(args);
+          case "health_check":
+            return await healthCheck(args);
+          case "get_smart_standards":
+            return await getSmartStandards(args);
+          case "use_preset":
+            return await usePreset(args);
+          case "list_presets":
+            return await listPresets();
+          case "match_agents":
+            return await matchAgents(args);
+          case "list_available_agents":
+            return await listAvailableAgents();
+          case "generate_config":
+            return await generateConfig(args);
+          case "get_compact_standards":
+            return await getCompactStandards(args);
+          case "get_relevant_standards":
+            return this.getRelevantStandards(args);
+          case "get_standards_stats":
+            return this.getStandardsStats(args);
+          case "get_standard_by_id":
+            return await getStandardById(args);
+          case "query_mappings":
+            return await queryMappings(args);
+          case "list_scenarios":
+            return await listScenarios();
+          case "list_templates":
+            return await listTemplates(args);
+          case "get_template":
+            return await getTemplate(args);
+          default:
+            throw new Error(`\u672A\u77E5\u5DE5\u5177: ${name}`);
+        }
+      } catch (error) {
+        logger2.error(`\u5DE5\u5177\u6267\u884C\u5931\u8D25:`, error);
+        return errorResponse(error);
+      }
+    });
+  }
+  /**
+   * 设置资源处理器
+   */
+  setupResourceHandlers() {
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      const standards = this.standardsManager.getAvailableStandards();
+      return {
+        resources: standards.map((std) => ({
+          uri: std.uri,
+          name: std.name,
+          description: std.description,
+          mimeType: "text/markdown"
+        }))
+      };
+    });
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+      try {
+        const content = this.standardsManager.readStandard(uri);
+        return {
+          contents: [{
+            uri,
+            mimeType: "text/markdown",
+            text: content
+          }]
+        };
+      } catch (error) {
+        throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u89C4\u8303 ${uri}: ${error}`);
+      }
+    });
+  }
+  /**
+   * 获取相关编码规范
+   */
+  getRelevantStandards(args) {
+    const standardUris = this.standardsManager.getRelevantStandards(args);
+    const content = this.standardsManager.combineStandards(standardUris);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          standards: standardUris,
+          content,
+          tokenEstimate: Math.ceil(content.length / 4),
+          // 粗略估算 token 数
+          message: `\u5DF2\u52A0\u8F7D ${standardUris.length} \u4E2A\u76F8\u5173\u89C4\u8303`
+        }, null, 2)
+      }]
+    };
+  }
+  /**
+   * 获取规范系统统计信息（Phase 3）
+   */
+  getStandardsStats(args) {
+    const usageStats = this.standardsManager.getUsageStats();
+    const performanceMetrics = this.standardsManager.getPerformanceMetrics();
+    const result = {
+      success: true,
+      usage: usageStats,
+      performance: performanceMetrics,
+      summary: {
+        totalCalls: usageStats.totalCalls,
+        cacheHitRate: performanceMetrics.cacheHitRate,
+        totalTokensSaved: performanceMetrics.totalTokensSaved,
+        averageResponseTime: `${performanceMetrics.averageResponseTime.toFixed(2)}ms`
+      }
+    };
+    if (args.includeCache) {
+      result.cache = this.standardsManager.getCacheStats();
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }]
+    };
+  }
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    logger2.info(`Copilot Prompts MCP Server v${SERVER_VERSION} \u5DF2\u542F\u52A8`);
+  }
+};
+var server = new CopilotPromptsMCPServer();
+server.run().catch((error) => {
+  logger2.error("\u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map