mta-mcp 2.8.0 → 2.10.0

package/dist/index.js

@@ -1112,51 +1112,77 @@ async function matchAgents(args) {
   }
 }
 
-// src/tools/listAgents.ts
-init_resourceLoader();
-async function listAvailableAgents() {
-  const logger3 = new ConsoleLogger();
+// src/tools/listAvailableAgents.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname3 = path5.dirname(__filename2);
+function parseAgentFile(filePath) {
   try {
-    const resourceLoader = getResourceLoader(logger3);
-    logger3.log("\u6B63\u5728\u4ECE\u5305\u5185\u52A0\u8F7D Agents \u5217\u8868...");
-    const agents = resourceLoader.loadAllAgents();
-    const agentList = agents.map((agent) => ({
-      id: agent.id,
-      name: `${agent.id}.agent.md`,
-      title: agent.title,
-      description: agent.description || "\u6682\u65E0\u63CF\u8FF0",
-      path: agent.path,
-      tags: agent.tags
-    }));
+    const content = fs5.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    let title = "";
+    let description = "";
+    const tags = [];
+    const titleLine = lines.find((l) => l.trim().startsWith("# "));
+    if (titleLine) {
+      title = titleLine.replace(/^#\s*/, "").trim();
+    }
+    const descLine = lines.find((l) => l.trim().startsWith("> "));
+    if (descLine) {
+      description = descLine.replace(/^>\s*/, "").trim();
+    }
+    const fileName = path5.basename(filePath);
+    const id = fileName.replace(".agent.md", "");
+    const tagsLine = lines.find(
+      (l) => l.includes("**\u6807\u7B7E**") || l.includes("**\u5173\u952E\u8BCD**") || l.includes("**Tags**")
+    );
+    if (tagsLine) {
+      const tagsMatch = tagsLine.match(/[:：]\s*(.+)/);
+      if (tagsMatch) {
+        tags.push(...tagsMatch[1].split(/[,，、]/).map((t) => t.trim()));
+      }
+    }
     return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          total: agentList.length,
-          agents: agentList,
-          source: "npm-package",
-          version: resourceLoader.getPackageVersion()
-        }, null, 2)
-      }]
+      id,
+      title: title || id,
+      description: description || "\u6682\u65E0\u63CF\u8FF0",
+      tags
     };
   } catch (error) {
-    logger3.error(`\u83B7\u53D6 Agents \u5217\u8868\u5931\u8D25: ${error}`);
+    console.error(`\u89E3\u6790 Agent \u6587\u4EF6\u5931\u8D25: ${filePath}`, error);
+    return null;
+  }
+}
+function listAvailableAgents() {
+  try {
+    const projectRoot = path5.resolve(__dirname3, "../..");
+    const agentsDir = path5.join(projectRoot, "agents");
+    if (!fs5.existsSync(agentsDir)) {
+      throw new Error(`Agents \u76EE\u5F55\u4E0D\u5B58\u5728: ${agentsDir}`);
+    }
+    const agentFiles = fs5.readdirSync(agentsDir).filter((f) => f.endsWith(".agent.md") && !f.endsWith(".bak")).map((f) => path5.join(agentsDir, f));
+    const agents = [];
+    for (const filePath of agentFiles) {
+      const metadata = parseAgentFile(filePath);
+      if (metadata) {
+        agents.push(metadata);
+      }
+    }
     return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          error: error instanceof Error ? error.message : String(error)
-        }, null, 2)
-      }]
+      agents: agents.sort((a, b) => a.title.localeCompare(b.title))
     };
+  } catch (error) {
+    console.error("\u5217\u51FA Agents \u5931\u8D25:", error);
+    return { agents: [] };
   }
 }
 
 // src/tools/generateConfig.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/core/githubClient.ts
 import axios from "axios";
@@ -1478,12 +1504,12 @@ var CodeValidator = class {
 
 // src/tools/generateConfig.ts
 init_resourceLoader();
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname3 = path5.dirname(__filename2);
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname4 = path6.dirname(__filename3);
 async function generateConfig(args) {
   const logger3 = new ConsoleLogger();
   try {
-    if (!fs5.existsSync(args.projectPath)) {
+    if (!fs6.existsSync(args.projectPath)) {
       return {
         content: [{
           type: "text",
@@ -1500,7 +1526,7 @@ async function generateConfig(args) {
       logger3.log("\u6B63\u5728\u5206\u6790\u9879\u76EE\u7279\u5F81...");
       const workspaceFolder = {
         uri: { fsPath: args.projectPath },
-        name: path5.basename(args.projectPath),
+        name: path6.basename(args.projectPath),
         index: 0
       };
       const features = await matcher.analyzeProject(workspaceFolder);
@@ -1540,19 +1566,19 @@ async function generateConfig(args) {
       };
     }
     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");
+    const githubDir = path6.join(args.projectPath, ".github");
+    const configPath = path6.join(githubDir, "copilot-instructions.md");
     let existingCustomContent = "";
     let existingConfig = "";
-    if (fs5.existsSync(configPath)) {
-      existingConfig = fs5.readFileSync(configPath, "utf-8");
+    if (fs6.existsSync(configPath)) {
+      existingConfig = fs6.readFileSync(configPath, "utf-8");
       const customMatch = existingConfig.match(/<!-- CUSTOM_START -->([\s\S]*?)<!-- CUSTOM_END -->/g);
       if (customMatch) {
         existingCustomContent = customMatch.join("\n\n");
       }
     }
-    if (!fs5.existsSync(githubDir)) {
-      fs5.mkdirSync(githubDir, { recursive: true });
+    if (!fs6.existsSync(githubDir)) {
+      fs6.mkdirSync(githubDir, { recursive: true });
     }
     const updateMode = args.updateMode || "merge";
     let content = "";
@@ -1577,7 +1603,7 @@ async function generateConfig(args) {
 
 `;
     }
-    const projectName = path5.basename(args.projectPath);
+    const projectName = path6.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 -->
 `;
@@ -1670,9 +1696,9 @@ async function generateConfig(args) {
 `;
     if (args.configId) {
       try {
-        const configFilePath = path5.join(__dirname3, "../../../configs", `element-plus-${args.configId}.json`);
-        if (fs5.existsSync(configFilePath)) {
-          const configData = JSON.parse(fs5.readFileSync(configFilePath, "utf-8"));
+        const configFilePath = path6.join(__dirname4, "../../../configs", `element-plus-${args.configId}.json`);
+        if (fs6.existsSync(configFilePath)) {
+          const configData = JSON.parse(fs6.readFileSync(configFilePath, "utf-8"));
           content += `## \u{1F4E6} \u914D\u7F6E\u65B9\u6848
 
 `;
@@ -1836,13 +1862,13 @@ async function generateConfig(args) {
     } else {
       logger3.log("\u2705 \u914D\u7F6E\u5185\u5BB9\u9A8C\u8BC1\u901A\u8FC7");
     }
-    fs5.writeFileSync(configPath, content, "utf-8");
-    const gitignorePath = path5.join(args.projectPath, ".gitignore");
-    if (fs5.existsSync(gitignorePath)) {
-      let gitignoreContent = fs5.readFileSync(gitignorePath, "utf-8");
+    fs6.writeFileSync(configPath, content, "utf-8");
+    const gitignorePath = path6.join(args.projectPath, ".gitignore");
+    if (fs6.existsSync(gitignorePath)) {
+      let gitignoreContent = fs6.readFileSync(gitignorePath, "utf-8");
       if (!gitignoreContent.includes(".github/copilot-instructions.md")) {
         gitignoreContent += "\n# Copilot Prompts (auto-generated)\n.github/copilot-instructions.md\n";
-        fs5.writeFileSync(gitignorePath, gitignoreContent, "utf-8");
+        fs6.writeFileSync(gitignorePath, gitignoreContent, "utf-8");
       }
     }
     logger3.log(`\u2705 \u914D\u7F6E\u6587\u4EF6\u5DF2\u751F\u6210: ${configPath}`);
@@ -1875,14 +1901,14 @@ async function generateConfig(args) {
 }
 
 // src/tools/autoSetup.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 async function autoSetup(args) {
   var _a;
   const logger3 = new ConsoleLogger();
   try {
     const workspacePath = args.workspacePath || process.cwd();
-    if (!fs6.existsSync(workspacePath)) {
+    if (!fs7.existsSync(workspacePath)) {
       return {
         content: [{
           type: "text",
@@ -1899,8 +1925,8 @@ async function autoSetup(args) {
     };
     logger3.log("\u{1F680} \u5F00\u59CB\u4E3A\u9879\u76EE\u751F\u6210 copilot-instructions.md...");
     const generateInstructions = args.generateInstructions !== false;
-    const instructionsPath = path6.join(workspacePath, ".github", "copilot-instructions.md");
-    const hasExistingInstructions = fs6.existsSync(instructionsPath);
+    const instructionsPath = path7.join(workspacePath, ".github", "copilot-instructions.md");
+    const hasExistingInstructions = fs7.existsSync(instructionsPath);
     if (generateInstructions) {
       if (hasExistingInstructions) {
         results.steps.push({
@@ -1972,12 +1998,85 @@ async function autoSetup(args) {
   }
 }
 
+// src/tools/initProject.ts
+import * as fs8 from "fs";
+async function initProject(args) {
+  var _a;
+  const logger3 = new ConsoleLogger();
+  try {
+    let projectPath = args.projectPath;
+    if (!projectPath) {
+      projectPath = process.cwd();
+      logger3.log(`\u{1F4A1} \u672A\u6307\u5B9A\u9879\u76EE\u8DEF\u5F84\uFF0C\u4F7F\u7528\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55: ${projectPath}`);
+    }
+    if (!fs8.existsSync(projectPath)) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: `\u9879\u76EE\u8DEF\u5F84\u4E0D\u5B58\u5728: ${projectPath}`,
+            tip: "\u8BF7\u5728 Chat \u4E2D\u6DFB\u52A0\u9879\u76EE\u6587\u4EF6\u5939\uFF0C\u6216\u660E\u786E\u6307\u5B9A\u9879\u76EE\u8DEF\u5F84"
+          }, null, 2)
+        }]
+      };
+    }
+    logger3.log(`\u{1F680} \u5F00\u59CB\u521D\u59CB\u5316\u9879\u76EE: ${projectPath}`);
+    const result = await generateConfig({
+      projectPath,
+      autoMatch: true,
+      updateMode: "merge"
+    });
+    const resultData = JSON.parse(result.content[0].text);
+    if (resultData.success) {
+      const agents = ((_a = resultData.agents) == null ? void 0 : _a.map((a) => a.id || a.title)) || [];
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            message: "\u{1F389} \u9879\u76EE\u521D\u59CB\u5316\u6210\u529F\uFF01",
+            projectPath,
+            configPath: resultData.configPath,
+            agents,
+            summary: `\u5DF2\u5E94\u7528 ${agents.length} \u4E2A Agents: ${agents.join(", ")}`,
+            nextSteps: [
+              "1. \u914D\u7F6E\u6587\u4EF6\u5DF2\u751F\u6210\uFF1A.github/copilot-instructions.md",
+              "2. \u73B0\u5728\u53EF\u4EE5\u5F00\u59CB\u7F16\u7801\uFF0CCopilot \u4F1A\u81EA\u52A8\u5E94\u7528\u9879\u76EE\u89C4\u8303",
+              '3. \u4F7F\u7528 @mta \u83B7\u53D6\u5177\u4F53\u89C4\u8303\uFF1A\u5982 "@mta Vue 3 \u7EC4\u4EF6\u89C4\u8303"'
+            ]
+          }, null, 2)
+        }]
+      };
+    } else {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: resultData.error || "\u521D\u59CB\u5316\u5931\u8D25",
+            projectPath
+          }, null, 2)
+        }]
+      };
+    }
+  } catch (error) {
+    logger3.error(`\u521D\u59CB\u5316\u5931\u8D25: ${error}`);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        }, null, 2)
+      }]
+    };
+  }
+}
+
 // src/core/standardsManager.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname4 = path7.dirname(__filename3);
+import * as fs9 from "fs";
+import * as path8 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname5 = path8.dirname(__filename4);
 var StandardsManager = class {
   constructor() {
     // v1.2.0: 底层必须加载的核心规范
@@ -2010,9 +2109,9 @@ var StandardsManager = class {
       averageResponseTime: 0,
       totalTokensSaved: 0
     };
-    const devPath = path7.resolve(__dirname4, "../../../standards");
-    const npmPath = path7.resolve(__dirname4, "../../standards");
-    this.standardsPath = fs7.existsSync(npmPath) ? npmPath : devPath;
+    const devPath = path8.resolve(__dirname5, "../../../standards");
+    const npmPath = path8.resolve(__dirname5, "../../standards");
+    this.standardsPath = fs9.existsSync(npmPath) ? npmPath : devPath;
   }
   /**
    * 获取所有可用的规范资源
@@ -2026,11 +2125,11 @@ var StandardsManager = class {
       { dir: "patterns", name: "\u8BBE\u8BA1\u6A21\u5F0F" }
     ];
     categories.forEach(({ dir, name: categoryName }) => {
-      const categoryPath = path7.join(this.standardsPath, dir);
-      if (!fs7.existsSync(categoryPath)) {
+      const categoryPath = path8.join(this.standardsPath, dir);
+      if (!fs9.existsSync(categoryPath)) {
         return;
       }
-      const files = fs7.readdirSync(categoryPath).filter((file) => file.endsWith(".md"));
+      const files = fs9.readdirSync(categoryPath).filter((file) => file.endsWith(".md"));
       files.forEach((file) => {
         const standardId = file.replace(".md", "");
         standards.push({
@@ -2060,11 +2159,11 @@ var StandardsManager = class {
       throw new Error(`Invalid standards URI: ${uri}`);
     }
     const [, category, standardId] = match;
-    const filePath = path7.join(this.standardsPath, category, `${standardId}.md`);
-    if (!fs7.existsSync(filePath)) {
+    const filePath = path8.join(this.standardsPath, category, `${standardId}.md`);
+    if (!fs9.existsSync(filePath)) {
       throw new Error(`Standard not found: ${uri}`);
     }
-    const content = fs7.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     this.updateCache(uri, content);
     this.stats.individualStandards.set(
       uri,
@@ -2607,23 +2706,23 @@ async function listPresets() {
 }
 
 // src/tools/healthCheck.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname5 = path8.dirname(__filename4);
+import * as fs10 from "fs";
+import * as path9 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var __filename5 = fileURLToPath5(import.meta.url);
+var __dirname6 = path9.dirname(__filename5);
 function getServerRoot() {
   const possibleRoots = [
-    path8.resolve(__dirname5, "../.."),
+    path9.resolve(__dirname6, "../.."),
     // 从 dist/tools/ 向上两级
-    path8.resolve(__dirname5, "../../.."),
+    path9.resolve(__dirname6, "../../.."),
     // npm 包场景
-    path8.resolve(process.cwd())
+    path9.resolve(process.cwd())
     // 当前工作目录
   ];
   for (const root of possibleRoots) {
-    const standardsPath = path8.join(root, "standards");
-    if (fs8.existsSync(standardsPath)) {
+    const standardsPath = path9.join(root, "standards");
+    if (fs10.existsSync(standardsPath)) {
       return root;
     }
   }
@@ -2653,14 +2752,14 @@ async function healthCheck(args) {
     }
     logger3.log("\u{1F50D} \u68C0\u67E5\u914D\u7F6E\u6587\u4EF6...");
     const workspacePath = args.workspacePath || process.cwd();
-    const vscodeDir = path8.join(workspacePath, ".vscode");
-    if (fs8.existsSync(vscodeDir)) {
+    const vscodeDir = path9.join(workspacePath, ".vscode");
+    if (fs10.existsSync(vscodeDir)) {
       checks.workspace.status = "healthy";
       checks.workspace.details.push(`\u2705 \u5DE5\u4F5C\u533A\u8DEF\u5F84: ${workspacePath}`);
-      const mcpJsonPath = path8.join(vscodeDir, "mcp.json");
-      if (fs8.existsSync(mcpJsonPath)) {
+      const mcpJsonPath = path9.join(vscodeDir, "mcp.json");
+      if (fs10.existsSync(mcpJsonPath)) {
         try {
-          const config = JSON.parse(fs8.readFileSync(mcpJsonPath, "utf-8"));
+          const config = JSON.parse(fs10.readFileSync(mcpJsonPath, "utf-8"));
           const hasNewFormat = (_a = config.servers) == null ? void 0 : _a["copilot-prompts"];
           const hasOldFormat = (_b = config.mcpServers) == null ? void 0 : _b["copilot-prompts"];
           if (hasNewFormat) {
@@ -2703,10 +2802,10 @@ async function healthCheck(args) {
         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 = path8.join(vscodeDir, "settings.json");
-      if (fs8.existsSync(settingsPath)) {
+      const settingsPath = path9.join(vscodeDir, "settings.json");
+      if (fs10.existsSync(settingsPath)) {
         try {
-          const settings = JSON.parse(fs8.readFileSync(settingsPath, "utf-8"));
+          const settings = JSON.parse(fs10.readFileSync(settingsPath, "utf-8"));
           if (settings["github.copilot.chat.mcp.enabled"] === true) {
             checks.configuration.details.push("\u2705 VS Code MCP \u5DF2\u542F\u7528");
           } else {
@@ -2723,10 +2822,10 @@ async function healthCheck(args) {
     }
     logger3.log("\u{1F50D} \u68C0\u67E5\u4F9D\u8D56...");
     const serverRoot = getServerRoot();
-    const packageJsonPath = path8.join(serverRoot, "package.json");
-    if (fs8.existsSync(packageJsonPath)) {
+    const packageJsonPath = path9.join(serverRoot, "package.json");
+    if (fs10.existsSync(packageJsonPath)) {
       try {
-        const pkg = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+        const pkg = JSON.parse(fs10.readFileSync(packageJsonPath, "utf-8"));
         checks.dependencies.status = "healthy";
         checks.dependencies.details.push(`\u2705 \u670D\u52A1\u5668\u7248\u672C: ${pkg.version}`);
         if (verbose && pkg.dependencies) {
@@ -2750,14 +2849,14 @@ async function healthCheck(args) {
       }
     }
     logger3.log("\u{1F50D} \u68C0\u67E5\u89C4\u8303\u6587\u4EF6...");
-    const standardsDir = path8.join(serverRoot, "standards");
-    if (fs8.existsSync(standardsDir)) {
+    const standardsDir = path9.join(serverRoot, "standards");
+    if (fs10.existsSync(standardsDir)) {
       const categories = ["core", "frameworks", "libraries", "patterns"];
       const foundStandards = [];
       for (const category of categories) {
-        const categoryPath = path8.join(standardsDir, category);
-        if (fs8.existsSync(categoryPath)) {
-          const files = fs8.readdirSync(categoryPath).filter((f) => f.endsWith(".md"));
+        const categoryPath = path9.join(standardsDir, category);
+        if (fs10.existsSync(categoryPath)) {
+          const files = fs10.readdirSync(categoryPath).filter((f) => f.endsWith(".md"));
           foundStandards.push(...files.map((f) => `${category}/${f}`));
         }
       }
@@ -2834,13 +2933,19 @@ function generateRecommendations(checks) {
 }
 
 // src/tools/getCompactStandards.ts
-import * as fs9 from "fs";
+import * as fs11 from "fs";
+import * as path10 from "path";
+init_smartAgentMatcher();
 async function getCompactStandards(args) {
   const logger3 = new ConsoleLogger();
   const manager = new StandardsManager();
   const mode = args.mode || "key-rules";
   try {
-    const context = detectContext(args, logger3);
+    let context = detectContext(args, logger3);
+    if (args.projectPath && fs11.existsSync(args.projectPath)) {
+      const projectContext = await analyzeProject2(args.projectPath, logger3);
+      context = mergeContexts(context, projectContext);
+    }
     const standardUris = manager.getRelevantStandards({
       fileType: context.fileType,
       imports: context.imports,
@@ -2858,6 +2963,13 @@ async function getCompactStandards(args) {
         responseContent = buildFullResponse(standardUris, manager);
         break;
     }
+    if (args.projectPath && context.userConfiguredAgents) {
+      responseContent.projectInfo = {
+        hasUserConfig: true,
+        userAgents: context.userConfiguredAgents,
+        message: "\u2705 \u5DF2\u8BFB\u53D6\u7528\u6237\u914D\u7F6E\u7684 Agents\uFF0C\u5E76\u8865\u5145\u4E86\u7F3A\u5931\u7684\u89C4\u8303"
+      };
+    }
     return {
       content: [{
         type: "text",
@@ -2876,12 +2988,74 @@ async function getCompactStandards(args) {
     };
   }
 }
+async function analyzeProject2(projectPath, logger3) {
+  var _a, _b;
+  const result = {
+    fileType: "unknown",
+    imports: [],
+    scenario: ""
+  };
+  const instructionsPath = path10.join(projectPath, ".github", "copilot-instructions.md");
+  if (fs11.existsSync(instructionsPath)) {
+    try {
+      const content = fs11.readFileSync(instructionsPath, "utf-8");
+      const agents = extractUserAgents(content);
+      if (agents.length > 0) {
+        result.userConfiguredAgents = agents;
+        logger3.log(`\u2705 \u68C0\u6D4B\u5230\u7528\u6237\u914D\u7F6E\u7684 Agents: ${agents.join(", ")}`);
+      }
+    } catch (error) {
+      logger3.error(`\u8BFB\u53D6\u7528\u6237\u914D\u7F6E\u5931\u8D25: ${error}`);
+    }
+  }
+  const matcher = new SmartAgentMatcher(logger3);
+  const workspaceFolder = {
+    uri: { fsPath: projectPath },
+    name: path10.basename(projectPath),
+    index: 0
+  };
+  try {
+    const features = await matcher.analyzeProject(workspaceFolder);
+    if ((_a = features.frameworks) == null ? void 0 : _a.includes("vue")) {
+      result.fileType = "vue";
+      result.imports.push("vue");
+    }
+    if ((_b = features.frameworks) == null ? void 0 : _b.includes("flutter")) {
+      result.fileType = "dart";
+      result.imports.push("flutter");
+    }
+    if (features.libraries) {
+      result.imports.push(...features.libraries);
+    }
+    logger3.log(`\u{1F50D} \u9879\u76EE\u6280\u672F\u6808: ${result.imports.join(", ")}`);
+  } catch (error) {
+    logger3.error(`\u9879\u76EE\u5206\u6790\u5931\u8D25: ${error}`);
+  }
+  return result;
+}
+function extractUserAgents(content) {
+  const agents = [];
+  const agentIdRegex = /- \*\*Agent ID\*\*:\s*`([^`]+)`/g;
+  let match;
+  while ((match = agentIdRegex.exec(content)) !== null) {
+    agents.push(match[1]);
+  }
+  return agents;
+}
+function mergeContexts(fileContext, projectContext) {
+  return {
+    fileType: fileContext.fileType !== "unknown" ? fileContext.fileType : projectContext.fileType,
+    imports: [.../* @__PURE__ */ new Set([...fileContext.imports, ...projectContext.imports])],
+    scenario: fileContext.scenario || projectContext.scenario,
+    userConfiguredAgents: projectContext.userConfiguredAgents
+  };
+}
 function detectContext(args, logger3) {
   var _a;
   let fileType = "unknown";
   let imports = [];
   let scenario = "";
-  if (args.currentFile && fs9.existsSync(args.currentFile)) {
+  if (args.currentFile && fs11.existsSync(args.currentFile)) {
     const ext = ((_a = args.currentFile.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
     const extMap = {
       "vue": "vue",
@@ -2893,7 +3067,7 @@ function detectContext(args, logger3) {
     };
     fileType = extMap[ext] || "unknown";
     try {
-      const content = fs9.readFileSync(args.currentFile, "utf-8");
+      const content = fs11.readFileSync(args.currentFile, "utf-8");
       imports = extractImports(content);
       scenario = inferScenario(content, fileType);
     } catch {
@@ -3210,8 +3384,8 @@ function inferScenario(content, fileType) {
 }
 
 // src/tools/getStandardById.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs12 from "fs";
+import * as path11 from "path";
 var STANDARD_DIRS = [
   "standards/core",
   "standards/frameworks",
@@ -3249,7 +3423,7 @@ async function getStandardById(args) {
         continue;
       }
       try {
-        const fullContent = fs10.readFileSync(filePath, "utf-8");
+        const fullContent = fs12.readFileSync(filePath, "utf-8");
         const content = formatContent(fullContent, mode);
         results.push({
           id,
@@ -3306,33 +3480,33 @@ function ensureCache() {
   standardsCache = /* @__PURE__ */ new Map();
   const baseDir = findBaseDir();
   for (const dir of STANDARD_DIRS) {
-    const fullDir = path9.join(baseDir, dir);
-    if (!fs10.existsSync(fullDir)) continue;
+    const fullDir = path11.join(baseDir, dir);
+    if (!fs12.existsSync(fullDir)) continue;
     scanDirectory(fullDir, standardsCache);
   }
 }
 function findBaseDir() {
   const possiblePaths = [
     process.cwd(),
-    path9.join(process.cwd(), ".."),
-    path9.join(__dirname, "..", "..", "..")
+    path11.join(process.cwd(), ".."),
+    path11.join(__dirname, "..", "..", "..")
   ];
   for (const p of possiblePaths) {
-    if (fs10.existsSync(path9.join(p, "standards"))) {
+    if (fs12.existsSync(path11.join(p, "standards"))) {
       return p;
     }
   }
   return process.cwd();
 }
 function scanDirectory(dir, cache) {
-  const items = fs10.readdirSync(dir);
+  const items = fs12.readdirSync(dir);
   for (const item of items) {
-    const fullPath = path9.join(dir, item);
-    const stat = fs10.statSync(fullPath);
+    const fullPath = path11.join(dir, item);
+    const stat = fs12.statSync(fullPath);
     if (stat.isDirectory()) {
       scanDirectory(fullPath, cache);
     } else if (item.endsWith(".md")) {
-      const id = path9.basename(item, ".md");
+      const id = path11.basename(item, ".md");
       cache.set(id, fullPath);
     }
   }
@@ -3575,10 +3749,10 @@ async function listScenarios() {
 }
 
 // src/core/templates/discovery.ts
-import * as fs11 from "fs";
-import * as path10 from "path";
-var TEMPLATES_DIR = path10.resolve(
-  path10.dirname(new URL(import.meta.url).pathname),
+import * as fs13 from "fs";
+import * as path12 from "path";
+var TEMPLATES_DIR = path12.resolve(
+  path12.dirname(new URL(import.meta.url).pathname),
   "../../../../templates"
 );
 var templatesCache = null;
@@ -3588,15 +3762,15 @@ function ensureCache2() {
   scanTemplates(TEMPLATES_DIR, "");
 }
 function scanTemplates(dir, prefix) {
-  if (!fs11.existsSync(dir)) return;
-  const entries = fs11.readdirSync(dir, { withFileTypes: true });
+  if (!fs13.existsSync(dir)) return;
+  const entries = fs13.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-    const fullPath = path10.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     const templateId = prefix ? `${prefix}/${entry.name}` : entry.name;
-    const configPath = path10.join(fullPath, "_CONFIG.md");
-    if (fs11.existsSync(configPath)) {
+    const configPath = path12.join(fullPath, "_CONFIG.md");
+    if (fs13.existsSync(configPath)) {
       const metadata = parseConfigMd(configPath, templateId, fullPath);
       if (metadata) {
         templatesCache.set(templateId, metadata);
@@ -3607,7 +3781,7 @@ function scanTemplates(dir, prefix) {
 }
 function parseConfigMd(configPath, templateId, templateDir) {
   try {
-    const content = fs11.readFileSync(configPath, "utf-8");
+    const content = fs13.readFileSync(configPath, "utf-8");
     const titleMatch = content.match(/^#\s+(.+)$/m);
     const name = titleMatch ? titleMatch[1].trim() : templateId;
     const descMatch = content.match(/^>\s*(.+)$/m);
@@ -3650,14 +3824,14 @@ function inferTemplateType(templateId, name) {
 }
 function getTemplateFiles(dir, prefix = "") {
   const files = [];
-  const entries = fs11.readdirSync(dir, { withFileTypes: true });
+  const entries = fs13.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(path10.join(dir, entry.name), relativePath));
+      files.push(...getTemplateFiles(path12.join(dir, entry.name), relativePath));
     } else {
       files.push(relativePath);
     }
@@ -3712,9 +3886,9 @@ function getTemplateById(templateId, includeFiles = false) {
   ensureCache2();
   const metadata = templatesCache.get(templateId);
   if (!metadata) return null;
-  const templateDir = path10.join(TEMPLATES_DIR, templateId);
-  const configPath = path10.join(templateDir, "_CONFIG.md");
-  const configGuide = fs11.existsSync(configPath) ? fs11.readFileSync(configPath, "utf-8") : "";
+  const templateDir = path12.join(TEMPLATES_DIR, templateId);
+  const configPath = path12.join(templateDir, "_CONFIG.md");
+  const configGuide = fs13.existsSync(configPath) ? fs13.readFileSync(configPath, "utf-8") : "";
   const result = {
     metadata,
     configGuide
@@ -3722,11 +3896,11 @@ function getTemplateById(templateId, includeFiles = false) {
   if (includeFiles) {
     result.files = [];
     for (const filePath of metadata.files) {
-      const fullPath = path10.join(templateDir, filePath);
-      if (fs11.existsSync(fullPath)) {
+      const fullPath = path12.join(templateDir, filePath);
+      if (fs13.existsSync(fullPath)) {
         result.files.push({
           path: filePath,
-          content: fs11.readFileSync(fullPath, "utf-8"),
+          content: fs13.readFileSync(fullPath, "utf-8"),
           isConfig: filePath.startsWith("_")
         });
       }
@@ -3737,7 +3911,7 @@ function getTemplateById(templateId, includeFiles = false) {
 function getTemplateDir(templateId) {
   ensureCache2();
   if (!templatesCache.has(templateId)) return null;
-  return path10.join(TEMPLATES_DIR, templateId);
+  return path12.join(TEMPLATES_DIR, templateId);
 }
 function searchTemplates(query) {
   const lower = query.toLowerCase();
@@ -4023,8 +4197,8 @@ function createLogger(name) {
 }
 
 // src/core/autoConfig.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs14 from "fs";
+import * as path13 from "path";
 var checkedWorkspaces = /* @__PURE__ */ new Map();
 var CACHE_DURATION = 5 * 60 * 1e3;
 function ensureWorkspaceConfig(workspacePath) {
@@ -4034,7 +4208,7 @@ function ensureWorkspaceConfig(workspacePath) {
     wasFixed: false,
     workspacePath
   };
-  if (!workspacePath || !fs12.existsSync(workspacePath)) {
+  if (!workspacePath || !fs14.existsSync(workspacePath)) {
     return result;
   }
   const cached = checkedWorkspaces.get(workspacePath);
@@ -4042,13 +4216,13 @@ function ensureWorkspaceConfig(workspacePath) {
   if (cached && cached.configured && now - cached.timestamp < CACHE_DURATION) {
     return result;
   }
-  const vscodeDir = path11.join(workspacePath, ".vscode");
-  const mcpJsonPath = path11.join(vscodeDir, "mcp.json");
-  const settingsPath = path11.join(vscodeDir, "settings.json");
+  const vscodeDir = path13.join(workspacePath, ".vscode");
+  const mcpJsonPath = path13.join(vscodeDir, "mcp.json");
+  const settingsPath = path13.join(vscodeDir, "settings.json");
   let hasMtaConfig = false;
-  if (fs12.existsSync(mcpJsonPath)) {
+  if (fs14.existsSync(mcpJsonPath)) {
     try {
-      const config = JSON.parse(fs12.readFileSync(mcpJsonPath, "utf-8"));
+      const config = JSON.parse(fs14.readFileSync(mcpJsonPath, "utf-8"));
       hasMtaConfig = !!(((_a = config.servers) == null ? void 0 : _a.mta) || ((_b = config.mcpServers) == null ? void 0 : _b.mta));
     } catch {
     }
@@ -4059,13 +4233,13 @@ function ensureWorkspaceConfig(workspacePath) {
   }
   result.needsSetup = true;
   try {
-    if (!fs12.existsSync(vscodeDir)) {
-      fs12.mkdirSync(vscodeDir, { recursive: true });
+    if (!fs14.existsSync(vscodeDir)) {
+      fs14.mkdirSync(vscodeDir, { recursive: true });
     }
     let mcpConfig = { servers: {} };
-    if (fs12.existsSync(mcpJsonPath)) {
+    if (fs14.existsSync(mcpJsonPath)) {
       try {
-        mcpConfig = JSON.parse(fs12.readFileSync(mcpJsonPath, "utf-8"));
+        mcpConfig = JSON.parse(fs14.readFileSync(mcpJsonPath, "utf-8"));
         if (!mcpConfig.servers) {
           mcpConfig.servers = {};
         }
@@ -4078,21 +4252,21 @@ function ensureWorkspaceConfig(workspacePath) {
       args: ["-y", "mta-mcp"],
       env: {}
     };
-    fs12.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+    fs14.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
     let settings = {};
-    if (fs12.existsSync(settingsPath)) {
+    if (fs14.existsSync(settingsPath)) {
       try {
-        settings = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
+        settings = JSON.parse(fs14.readFileSync(settingsPath, "utf-8"));
       } catch {
         settings = {};
       }
     }
     if (!settings["github.copilot.chat.mcp.enabled"]) {
       settings["github.copilot.chat.mcp.enabled"] = true;
-      fs12.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+      fs14.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
     }
     result.wasFixed = true;
-    result.message = `\u2705 \u5DF2\u81EA\u52A8\u4E3A ${path11.basename(workspacePath)} \u914D\u7F6E MTA MCP\u3002\u8BF7\u91CD\u65B0\u52A0\u8F7D VS Code \u7A97\u53E3\u4F7F\u914D\u7F6E\u751F\u6548\u3002`;
+    result.message = `\u2705 \u5DF2\u81EA\u52A8\u4E3A ${path13.basename(workspacePath)} \u914D\u7F6E MTA MCP\u3002\u8BF7\u91CD\u65B0\u52A0\u8F7D VS Code \u7A97\u53E3\u4F7F\u914D\u7F6E\u751F\u6548\u3002`;
     checkedWorkspaces.set(workspacePath, { configured: true, timestamp: now });
   } catch (error) {
     result.message = `\u26A0\uFE0F \u81EA\u52A8\u914D\u7F6E\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`;
@@ -4190,6 +4364,35 @@ var CopilotPromptsMCPServer = class {
             required: ["workspacePath"]
           }
         },
+        {
+          name: "init_project",
+          description: `\u3010\u521D\u59CB\u5316\u9879\u76EE\u3011\u5FEB\u901F\u521D\u59CB\u5316\u9879\u76EE\u7684 MTA \u914D\u7F6E\u3002
+\u7528\u6CD5\uFF1A@mta \u521D\u59CB\u5316\u9879\u76EE
+
+\u529F\u80FD\uFF1A
+1. \u81EA\u52A8\u4ECE\u804A\u5929\u4E0A\u4E0B\u6587\u4E2D\u68C0\u6D4B\u9879\u76EE\u8DEF\u5F84\uFF08Chat \u4E2D\u6DFB\u52A0\u7684\u6587\u4EF6\u5939\uFF09
+2. \u5206\u6790\u9879\u76EE\u6280\u672F\u6808\u5E76\u751F\u6210 copilot-instructions.md
+3. \u5982\u679C\u5DF2\u5B58\u5728\u914D\u7F6E\uFF0C\u4F1A\u8BFB\u53D6\u7528\u6237\u5DF2\u914D\u7F6E\u7684 Agents \u5E76\u8865\u5145\u7F3A\u5931\u7684\u89C4\u8303
+
+\u63D0\u793A\uFF1A\u786E\u4FDD\u5728 Chat \u4E2D\u5DF2\u6DFB\u52A0\u9879\u76EE\u6587\u4EF6\u5939`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              projectPath: {
+                type: "string",
+                description: "\u9879\u76EE\u8DEF\u5F84\uFF08\u53EF\u9009\uFF0C\u5982\u679C\u4E0D\u63D0\u4F9B\u4F1A\u5C1D\u8BD5\u4ECE\u4E0A\u4E0B\u6587\u63A8\u65AD\uFF09"
+              }
+            }
+          }
+        },
+        {
+          name: "list_available_agents",
+          description: "\u5217\u51FA\u6240\u6709\u53EF\u7528\u7684 Agents\uFF08\u7528\u4E8E VSCode \u63D2\u4EF6\u7B49\u573A\u666F\uFF09\uFF0C\u8FD4\u56DE Agent \u5143\u6570\u636E\u5217\u8868",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
         {
           name: "health_check",
           description: "\u68C0\u67E5 MCP \u670D\u52A1\u5668\u72B6\u6001\u548C\u914D\u7F6E\u95EE\u9898\uFF0C\u8FD4\u56DE\u8BCA\u65AD\u62A5\u544A\u548C\u4FEE\u590D\u5EFA\u8BAE",
@@ -4306,7 +4509,16 @@ var CopilotPromptsMCPServer = class {
         },
         {
           name: "get_compact_standards",
-          description: "\u83B7\u53D6\u89C4\u8303\uFF08\u652F\u6301 summary/key-rules/full \u4E09\u79CD\u6A21\u5F0F\uFF0C\u9ED8\u8BA4 key-rules\uFF09",
+          description: `\u83B7\u53D6\u7F16\u7801\u89C4\u8303\uFF08\u667A\u80FD\u6A21\u5F0F\uFF09
+\u529F\u80FD\uFF1A
+1. \u81EA\u52A8\u5206\u6790\u9879\u76EE\u6280\u672F\u6808\uFF08\u901A\u8FC7 projectPath\uFF09
+2. \u5982\u679C\u5B58\u5728 copilot-instructions.md\uFF0C\u4F18\u5148\u4F7F\u7528\u7528\u6237\u914D\u7F6E\u7684 Agents
+3. \u667A\u80FD\u8865\u5145\u7528\u6237\u672A\u914D\u7F6E\u7684\u89C4\u8303
+4. \u652F\u6301 summary/key-rules/full \u4E09\u79CD\u8FD4\u56DE\u6A21\u5F0F
+
+\u4F7F\u7528\u573A\u666F\uFF1A
+- @mta \u8C03\u7528\u65F6\uFF0C\u4F20\u5165 projectPath \u83B7\u53D6\u5B8C\u6574\u9879\u76EE\u89C4\u8303
+- \u7F16\u5199\u4EE3\u7801\u65F6\uFF0C\u4F20\u5165 fileContent \u83B7\u53D6\u6587\u4EF6\u76F8\u5173\u89C4\u8303`,
           inputSchema: {
             type: "object",
             properties: {
@@ -4318,6 +4530,10 @@ var CopilotPromptsMCPServer = class {
                 type: "string",
                 description: "\u6587\u4EF6\u5185\u5BB9\uFF08\u53EF\u9009\uFF09"
               },
+              projectPath: {
+                type: "string",
+                description: "\u9879\u76EE\u6839\u8DEF\u5F84\uFF08\u63A8\u8350\uFF09- \u4F1A\u81EA\u52A8\u5206\u6790\u9879\u76EE\u6280\u672F\u6808\u5E76\u8BFB\u53D6\u7528\u6237\u914D\u7F6E"
+              },
               scenario: {
                 type: "string",
                 description: "\u5F00\u53D1\u573A\u666F\uFF08\u53EF\u9009\uFF09"
@@ -4325,7 +4541,7 @@ var CopilotPromptsMCPServer = class {
               mode: {
                 type: "string",
                 enum: ["summary", "key-rules", "full"],
-                description: "\u8FD4\u56DE\u6A21\u5F0F",
+                description: "\u8FD4\u56DE\u6A21\u5F0F\uFF1Asummary(\u6458\u8981)/key-rules(\u5173\u952E\u89C4\u5219,\u9ED8\u8BA4)/full(\u5B8C\u6574\u5185\u5BB9)",
                 default: "key-rules"
               }
             }
@@ -4460,6 +4676,9 @@ var CopilotPromptsMCPServer = class {
           case "auto_setup":
             result = await autoSetup(args);
             break;
+          case "init_project":
+            result = await initProject(args);
+            break;
           case "health_check":
             result = await healthCheck(args);
             break;
@@ -4473,7 +4692,7 @@ var CopilotPromptsMCPServer = class {
             result = await matchAgents(args);
             break;
           case "list_available_agents":
-            result = await listAvailableAgents();
+            result = listAvailableAgents();
             break;
           case "generate_config":
             result = await generateConfig(args);