mta-mcp 1.8.1

package/generate-project-config.cjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+/**
+ * 通用配置生成工具
+ * 可为任何项目生成 Copilot 配置
+ * 
+ * 使用方法:
+ *   node generate-project-config.cjs <项目路径> [配置ID] [agents...]
+ * 
+ * 示例:
+ *   # VitaSage 项目
+ *   node generate-project-config.cjs /Users/pailasi/Work/VitaSage vitasage vitasage,vue3,logicflow
+ * 
+ *   # Flutter 项目
+ *   node generate-project-config.cjs /Users/pailasi/Work/my_flutter flutter-recipe flutter
+ * 
+ *   # 微信小程序
+ *   node generate-project-config.cjs /Users/pailasi/Work/MTA-Market wechat wechat-miniprogram
+ * 
+ *   # 自动匹配
+ *   node generate-project-config.cjs /Users/pailasi/Work/weipin
+ */
+
+const { generateConfig } = require('./build/tools/generateConfig.js');
+
+async function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    console.log(`
+📋 通用配置生成工具
+
+使用方法:
+  node generate-project-config.cjs <项目路径> [配置ID] [agents]
+
+参数说明:
+  项目路径     必填，项目的绝对路径
+  配置ID       可选，配置方案ID（如 vitasage, flutter-recipe）
+  agents       可选，手动指定agents，用逗号分隔（如 vue3,pinia）
+
+示例:
+
+  # VitaSage 项目（使用 vitasage 配置方案）
+  node generate-project-config.cjs /Users/pailasi/Work/VitaSage vitasage vitasage,vue3,logicflow
+
+  # Flutter 项目（使用 flutter-recipe 配置方案）
+  node generate-project-config.cjs /Users/pailasi/Work/my_flutter flutter-recipe flutter
+
+  # 微信小程序（自动匹配 agents）
+  node generate-project-config.cjs /Users/pailasi/Work/MTA-Market wechat
+
+  # 标准 Vue 项目（自动匹配）
+  node generate-project-config.cjs /Users/pailasi/Work/weipin
+
+配置方案列表:
+  - vitasage         VitaSage 工业配方系统（Element Plus）
+  - flutter-recipe   Flutter 配方管理项目
+  - wechat          微信小程序标准配置
+  - standard        标准 Web 项目配置
+`);
+    process.exit(0);
+  }
+
+  const projectPath = args[0];
+  const configId = args[1] || undefined;
+  const agentIds = args[2] ? args[2].split(',').map(a => a.trim()) : undefined;
+
+  console.log(`🚀 生成配置`);
+  console.log(`   项目: ${projectPath}`);
+  if (configId) console.log(`   配置方案: ${configId}`);
+  if (agentIds) console.log(`   Agents: ${agentIds.join(', ')}`);
+  console.log('');
+
+  const result = await generateConfig({
+    projectPath,
+    agentIds,
+    autoMatch: !agentIds, // 如果没有指定agents，则自动匹配
+    updateMode: 'merge',  // 默认保护模式
+    configId,
+  });
+
+  const data = JSON.parse(result.content[0].text);
+  
+  if (data.success) {
+    console.log('\n✅ 成功！');
+    console.log(`\n配置文件: ${data.configPath}`);
+    console.log(`应用的 Agents: ${data.agents.map(a => a.id).join(', ')}`);
+  } else {
+    console.error('\n❌ 失败:', data.error);
+    process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error('❌ 错误:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "mta-mcp",
+  "version": "1.8.1",
+  "description": "MTA - 智能项目分析与编码规范管理 MCP 服务器",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "mta": "build/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "start": "node build/index.js",
+    "dev": "tsc --watch",
+    "prepare": "npm run build",
+    "clean": "rm -rf build"
+  },
+  "keywords": [
+    "mcp",
+    "copilot",
+    "ai",
+    "agents",
+    "github",
+    "claude"
+  ],
+  "author": "ForLear",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.3",
+    "axios": "^1.6.5",
+    "fast-glob": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ForLear/copilot-prompts.git",
+    "directory": "mcp-server"
+  }
+}

package/regenerate-vitasage.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# VitaSage 配置重新生成脚本
+# 使用 merge 模式，保护自定义内容
+
+set -e
+
+echo "🔄 重新生成 VitaSage 项目配置..."
+echo ""
+
+cd "$(dirname "$0")"
+
+# 编译最新代码
+echo "📦 编译 MCP 服务器..."
+npm run build
+
+echo ""
+echo "✨ 生成配置文件..."
+node test-vitasage-config.cjs
+
+echo ""
+echo "✅ 配置已更新！"
+echo ""
+echo "📋 配置文件位置: /Users/pailasi/Work/VitaSage/.github/copilot-instructions.md"
+echo ""
+echo "💡 提示："
+echo "  - 使用 CUSTOM_START/CUSTOM_END 标记可保护自定义内容"
+echo "  - 配置会自动应用 vitasage 配置方案"
+echo "  - 包含 3 个 Agents: vitasage, vue3, logicflow"
+echo ""

package/src/core/codeValidator.ts

@@ -0,0 +1,357 @@
+/**
+ * 代码验证器 (v1.1.0)
+ * 用于检测和防止常见的代码生成错误
+ */
+
+import { ConsoleLogger } from './types.js';
+
+/**
+ * 验证结果接口
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+
+/**
+ * 验证错误
+ */
+export interface ValidationError {
+    type: 'syntax' | 'completeness' | 'compatibility';
+    message: string;
+    line?: number;
+    suggestion?: string;
+}
+
+/**
+ * 验证警告
+ */
+export interface ValidationWarning {
+    type: 'best-practice' | 'performance' | 'compatibility' | 'completeness';
+    message: string;
+    suggestion?: string;
+}
+
+/**
+ * 代码验证器类
+ */
+export class CodeValidator {
+    private logger: ConsoleLogger;
+    
+    constructor(logger?: ConsoleLogger) {
+        this.logger = logger || new ConsoleLogger();
+    }
+
+    /**
+     * 验证生成的配置文件内容
+     */
+    validateConfigContent(content: string): ValidationResult {
+        const errors: ValidationError[] = [];
+        const warnings: ValidationWarning[] = [];
+
+        // 1. 检查重复标签闭合 (如 </style></style>)
+        this.checkDuplicateTags(content, errors);
+
+        // 2. 检查括号匹配
+        this.checkBracketMatching(content, errors);
+
+        // 3. 检查 Markdown 语法
+        this.checkMarkdownSyntax(content, errors);
+
+        // 4. 检查必要章节完整性
+        this.checkRequiredSections(content, warnings);
+
+        // 5. 检查自定义内容标记
+        this.checkCustomContentMarkers(content, warnings);
+
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+
+    /**
+     * 检查重复的HTML标签
+     */
+    private checkDuplicateTags(content: string, errors: ValidationError[]): void {
+        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 = new Map<string, number>();
+                
+                tags.forEach(tag => {
+                    tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+                });
+                
+                tagCounts.forEach((count, tag) => {
+                    if (count > 1) {
+                        errors.push({
+                            type: 'syntax',
+                            message: `重复的闭合标签 </${tag}> 在同一行出现 ${count} 次`,
+                            line: i + 1,
+                            suggestion: `检查是否有多余的闭合标签，应该只保留一个 </${tag}>`
+                        });
+                    }
+                });
+            }
+        }
+    }
+
+    /**
+     * 检查括号匹配
+     */
+    private checkBracketMatching(content: string, errors: ValidationError[]): void {
+        const brackets = {
+            '(': ')',
+            '[': ']',
+            '{': '}',
+            '<': '>'
+        };
+        
+        const stack: Array<{ char: string; line: number; col: number }> = [];
+        const lines = content.split('\n');
+        
+        for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+            const line = lines[lineNum];
+            
+            // 跳过代码块内容
+            if (line.trim().startsWith('```')) {
+                continue;
+            }
+            
+            // 跳过 Markdown blockquote 行（以 > 开头）
+            if (line.trim().startsWith('>')) {
+                continue;
+            }
+            
+            for (let col = 0; col < line.length; col++) {
+                const char = line[col];
+                
+                // 跳过 Markdown blockquote 的 > 符号
+                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: `未配对的闭合括号 '${char}'`,
+                            line: lineNum + 1,
+                            suggestion: `检查是否缺少对应的开放括号`
+                        });
+                    } else {
+                        const last = stack.pop()!;
+                        const expectedClose = brackets[last.char as keyof typeof brackets];
+                        
+                        if (char !== expectedClose) {
+                            errors.push({
+                                type: 'syntax',
+                                message: `括号不匹配: 期望 '${expectedClose}' 但得到 '${char}'`,
+                                line: lineNum + 1,
+                                suggestion: `检查第 ${last.line} 行的 '${last.char}' 对应的闭合括号`
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        
+        // 检查未闭合的括号
+        if (stack.length > 0) {
+            stack.forEach(bracket => {
+                errors.push({
+                    type: 'syntax',
+                    message: `未闭合的括号 '${bracket.char}'`,
+                    line: bracket.line,
+                    suggestion: `添加对应的闭合括号 '${brackets[bracket.char as keyof typeof brackets]}'`
+                });
+            });
+        }
+    }
+
+    /**
+     * 检查 Markdown 语法
+     */
+    private checkMarkdownSyntax(content: string, errors: ValidationError[]): void {
+        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: '未闭合的代码块',
+                line: codeBlockStart,
+                suggestion: '在代码块末尾添加 ``` 闭合标记'
+            });
+        }
+    }
+
+    /**
+     * 检查必要章节完整性
+     */
+    private checkRequiredSections(content: string, warnings: ValidationWarning[]): void {
+        const requiredSections = [
+            { pattern: /## ⚠️ 强制工作流/i, name: '强制工作流章节' },
+            { pattern: /## 📚 配置的 Agents/i, name: 'Agents 配置章节' }
+        ];
+        
+        requiredSections.forEach(section => {
+            if (!section.pattern.test(content)) {
+                warnings.push({
+                    type: 'completeness',
+                    message: `缺少必要章节: ${section.name}`,
+                    suggestion: '确保生成的配置文件包含所有必要的章节'
+                });
+            }
+        });
+    }
+
+    /**
+     * 检查自定义内容标记
+     */
+    private checkCustomContentMarkers(content: string, warnings: ValidationWarning[]): void {
+        const hasCustomStart = content.includes('<!-- CUSTOM_START -->');
+        const hasCustomEnd = content.includes('<!-- CUSTOM_END -->');
+        
+        if (hasCustomStart !== hasCustomEnd) {
+            warnings.push({
+                type: 'completeness',
+                message: 'CUSTOM 标记不完整',
+                suggestion: '确保 CUSTOM_START 和 CUSTOM_END 成对出现'
+            });
+        }
+    }
+
+    /**
+     * 验证 Agent 内容
+     */
+    validateAgentContent(content: string, agentId: string): ValidationResult {
+        const errors: ValidationError[] = [];
+        const warnings: ValidationWarning[] = [];
+
+        // 检查 Agent 文件的特殊要求
+        if (!content.includes('⚠️ 强制工作流') && !content.includes('## 强制工作流')) {
+            warnings.push({
+                type: 'best-practice',
+                message: `Agent ${agentId} 缺少强制工作流说明`,
+                suggestion: '建议在 Agent 中包含 MCP 工具调用的强制说明'
+            });
+        }
+
+        // 基本语法检查
+        const syntaxValidation = this.validateConfigContent(content);
+        errors.push(...syntaxValidation.errors);
+        warnings.push(...syntaxValidation.warnings);
+
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+
+    /**
+     * 生成验证报告
+     */
+    generateValidationReport(result: ValidationResult): string {
+        let report = '';
+        
+        if (result.isValid && result.warnings.length === 0) {
+            report = '✅ 验证通过，未发现问题\n';
+            return report;
+        }
+        
+        if (!result.isValid) {
+            report += '❌ 验证失败，发现以下错误：\n\n';
+            result.errors.forEach((error, index) => {
+                report += `${index + 1}. [${error.type}] ${error.message}\n`;
+                if (error.line) {
+                    report += `   位置: 第 ${error.line} 行\n`;
+                }
+                if (error.suggestion) {
+                    report += `   建议: ${error.suggestion}\n`;
+                }
+                report += '\n';
+            });
+        } else {
+            report += '✅ 验证通过\n\n';
+        }
+        
+        if (result.warnings.length > 0) {
+            report += '⚠️ 发现以下警告：\n\n';
+            result.warnings.forEach((warning, index) => {
+                report += `${index + 1}. [${warning.type}] ${warning.message}\n`;
+                if (warning.suggestion) {
+                    report += `   建议: ${warning.suggestion}\n`;
+                }
+                report += '\n';
+            });
+        }
+        
+        return report;
+    }
+
+    /**
+     * 尝试自动修复简单的语法错误
+     */
+    attemptAutoFix(content: string): { fixed: boolean; content: string; changes: string[] } {
+        let fixedContent = content;
+        const changes: string[] = [];
+
+        // 1. 修复重复的闭合标签
+        const tagPattern = /(<\/([\w-]+)>)\1+/g;
+        const tagMatches = content.match(tagPattern);
+        if (tagMatches) {
+            fixedContent = fixedContent.replace(tagPattern, '$1');
+            changes.push(`修复了重复的闭合标签: ${tagMatches.join(', ')}`);
+        }
+
+        // 2. 修复未闭合的代码块
+        const codeBlockCount = (fixedContent.match(/```/g) || []).length;
+        if (codeBlockCount % 2 !== 0) {
+            fixedContent += '\n```\n';
+            changes.push('添加了缺失的代码块闭合标记');
+        }
+
+        return {
+            fixed: changes.length > 0,
+            content: fixedContent,
+            changes
+        };
+    }
+}
+
+/**
+ * 创建默认验证器实例
+ */
+export function createValidator(logger?: ConsoleLogger): CodeValidator {
+    return new CodeValidator(logger);
+}

package/src/core/githubClient.ts

@@ -0,0 +1,64 @@
+import axios from 'axios';
+import { Logger } from './types.js';
+
+/**
+ * GitHub 客户端（Node.js 版本，无 VS Code 依赖）
+ */
+export class GitHubClient {
+    private readonly owner = 'ForLear';
+    private readonly repo = 'copilot-prompts';
+    private readonly branch = 'main';
+    private readonly baseUrl = 'https://api.github.com';
+    private readonly rawBaseUrl = 'https://raw.githubusercontent.com';
+
+    constructor(private logger?: Logger) {}
+
+    /**
+     * 列出目录中的文件
+     */
+    async listDirectoryFiles(dirPath: string): Promise<Array<{ name: string; path: string; type: string }>> {
+        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: any) => ({
+                    name: item.name,
+                    path: item.path,
+                    type: item.type
+                }));
+            }
+
+            return [];
+        } catch (error) {
+            this.logger?.error(`获取目录失败: ${error}`);
+            return [];
+        }
+    }
+
+    /**
+     * 获取文件内容
+     */
+    async fetchFileContent(filePath: string): Promise<string> {
+        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) {
+            this.logger?.error(`获取文件失败: ${filePath}`);
+            throw error;
+        }
+    }
+}