mcp-probe-kit 2.0.2 → 2.1.1

package/build/lib/document-templates.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 文档模板配置
+ *
+ * 根据项目类型（category）定义需要生成的文档列表
+ */
+export interface DocumentTemplate {
+    filename: string;
+    title: string;
+    purpose: string;
+}
+/**
+ * 根据项目类型获取文档列表
+ */
+export declare function getDocumentTemplates(category: string): DocumentTemplate[];

package/build/lib/document-templates.js

@@ -0,0 +1,248 @@
+/**
+ * 文档模板配置
+ *
+ * 根据项目类型（category）定义需要生成的文档列表
+ */
+/**
+ * 根据项目类型获取文档列表
+ */
+export function getDocumentTemplates(category) {
+    const templates = documentTemplatesByCategory[category];
+    if (!templates) {
+        // 未知类型，返回通用模板
+        return documentTemplatesByCategory['unknown'];
+    }
+    return templates;
+}
+/**
+ * 各类型项目的文档模板配置
+ */
+const documentTemplatesByCategory = {
+    // 后端 API 项目
+    'backend-api': [
+        {
+            filename: 'how-to-add-api.md',
+            title: '如何添加新接口',
+            purpose: '指导开发者如何在项目中添加新的 API 接口'
+        },
+        {
+            filename: 'how-to-database.md',
+            title: '如何操作数据库',
+            purpose: '指导开发者如何连接和操作数据库'
+        },
+        {
+            filename: 'how-to-auth.md',
+            title: '如何处理认证',
+            purpose: '指导开发者如何实现用户认证和授权'
+        },
+        {
+            filename: 'how-to-test.md',
+            title: '如何编写测试',
+            purpose: '指导开发者如何编写单元测试和集成测试'
+        },
+        {
+            filename: 'how-to-deploy.md',
+            title: '如何部署',
+            purpose: '指导开发者如何部署应用到生产环境'
+        }
+    ],
+    // 前端 SPA 项目
+    'frontend-spa': [
+        {
+            filename: 'how-to-new-page.md',
+            title: '如何创建新页面',
+            purpose: '指导开发者如何创建新的页面组件'
+        },
+        {
+            filename: 'how-to-call-api.md',
+            title: '如何调用 API',
+            purpose: '指导开发者如何调用后端 API 接口'
+        },
+        {
+            filename: 'how-to-state.md',
+            title: '如何管理状态',
+            purpose: '指导开发者如何使用状态管理工具'
+        },
+        {
+            filename: 'how-to-routing.md',
+            title: '如何处理路由',
+            purpose: '指导开发者如何配置和使用路由'
+        },
+        {
+            filename: 'how-to-styling.md',
+            title: '如何处理样式',
+            purpose: '指导开发者如何编写和组织样式代码'
+        }
+    ],
+    // 全栈项目
+    'fullstack': [
+        {
+            filename: 'how-to-new-feature.md',
+            title: '如何开发新功能',
+            purpose: '指导开发者如何开发前后端联动的新功能'
+        },
+        {
+            filename: 'how-to-api-route.md',
+            title: '如何添加 API 路由',
+            purpose: '指导开发者如何添加服务端 API 路由'
+        },
+        {
+            filename: 'how-to-new-page.md',
+            title: '如何创建新页面',
+            purpose: '指导开发者如何创建新的页面'
+        },
+        {
+            filename: 'how-to-database.md',
+            title: '如何操作数据库',
+            purpose: '指导开发者如何连接和操作数据库'
+        },
+        {
+            filename: 'how-to-deploy.md',
+            title: '如何部署',
+            purpose: '指导开发者如何部署全栈应用'
+        }
+    ],
+    // 移动端项目
+    'mobile': [
+        {
+            filename: 'how-to-new-screen.md',
+            title: '如何创建新屏幕',
+            purpose: '指导开发者如何创建新的屏幕页面'
+        },
+        {
+            filename: 'how-to-navigation.md',
+            title: '如何处理导航',
+            purpose: '指导开发者如何配置和使用导航'
+        },
+        {
+            filename: 'how-to-api.md',
+            title: '如何调用 API',
+            purpose: '指导开发者如何调用后端 API'
+        },
+        {
+            filename: 'how-to-state.md',
+            title: '如何管理状态',
+            purpose: '指导开发者如何管理应用状态'
+        },
+        {
+            filename: 'how-to-build.md',
+            title: '如何构建和发布',
+            purpose: '指导开发者如何构建和发布应用'
+        }
+    ],
+    // 桌面应用项目
+    'desktop': [
+        {
+            filename: 'how-to-new-window.md',
+            title: '如何创建新窗口',
+            purpose: '指导开发者如何创建新的窗口'
+        },
+        {
+            filename: 'how-to-ipc.md',
+            title: '如何进程通信',
+            purpose: '指导开发者如何实现主进程和渲染进程通信'
+        },
+        {
+            filename: 'how-to-native.md',
+            title: '如何调用原生 API',
+            purpose: '指导开发者如何调用系统原生 API'
+        },
+        {
+            filename: 'how-to-package.md',
+            title: '如何打包',
+            purpose: '指导开发者如何打包桌面应用'
+        }
+    ],
+    // 数据科学项目
+    'data-science': [
+        {
+            filename: 'how-to-new-analysis.md',
+            title: '如何开始新分析',
+            purpose: '指导开发者如何创建新的数据分析任务'
+        },
+        {
+            filename: 'how-to-data-load.md',
+            title: '如何加载数据',
+            purpose: '指导开发者如何加载和预处理数据'
+        },
+        {
+            filename: 'how-to-visualize.md',
+            title: '如何可视化',
+            purpose: '指导开发者如何创建数据可视化'
+        },
+        {
+            filename: 'how-to-model.md',
+            title: '如何训练模型',
+            purpose: '指导开发者如何训练和评估机器学习模型'
+        }
+    ],
+    // CLI 工具项目
+    'cli': [
+        {
+            filename: 'how-to-new-command.md',
+            title: '如何添加新命令',
+            purpose: '指导开发者如何添加新的 CLI 命令'
+        },
+        {
+            filename: 'how-to-args.md',
+            title: '如何处理参数',
+            purpose: '指导开发者如何解析和验证命令行参数'
+        },
+        {
+            filename: 'how-to-test.md',
+            title: '如何测试',
+            purpose: '指导开发者如何测试 CLI 工具'
+        },
+        {
+            filename: 'how-to-publish.md',
+            title: '如何发布',
+            purpose: '指导开发者如何发布 CLI 工具'
+        }
+    ],
+    // 库/SDK 项目
+    'library': [
+        {
+            filename: 'how-to-new-api.md',
+            title: '如何添加新 API',
+            purpose: '指导开发者如何添加新的公共 API'
+        },
+        {
+            filename: 'how-to-test.md',
+            title: '如何测试',
+            purpose: '指导开发者如何编写测试'
+        },
+        {
+            filename: 'how-to-docs.md',
+            title: '如何写文档',
+            purpose: '指导开发者如何编写 API 文档'
+        },
+        {
+            filename: 'how-to-publish.md',
+            title: '如何发布',
+            purpose: '指导开发者如何发布新版本'
+        }
+    ],
+    // 未知类型（通用）
+    'unknown': [
+        {
+            filename: 'project-overview.md',
+            title: '项目概览',
+            purpose: '项目的基本信息和技术栈'
+        },
+        {
+            filename: 'project-structure.md',
+            title: '项目结构',
+            purpose: '项目的目录结构和代码组织'
+        },
+        {
+            filename: 'development-guide.md',
+            title: '开发指南',
+            purpose: '如何在项目中进行开发'
+        },
+        {
+            filename: 'testing-guide.md',
+            title: '测试指南',
+            purpose: '如何运行和编写测试'
+        }
+    ]
+};

package/build/lib/project-detector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 项目类型检测模块
+ *
+ * 功能：
+ * - 检测项目使用的编程语言
+ * - 检测项目使用的框架
+ * - 判断项目类型（后端/前端/全栈等）
+ */
+export interface ProjectDetectionResult {
+    language: string;
+    category: string;
+    framework?: string;
+    confidence: number;
+    indicators: string[];
+}
+/**
+ * 检测项目类型
+ */
+export declare function detectProjectType(projectRoot?: string): ProjectDetectionResult;

package/build/lib/project-detector.js

@@ -0,0 +1,344 @@
+/**
+ * 项目类型检测模块
+ *
+ * 功能：
+ * - 检测项目使用的编程语言
+ * - 检测项目使用的框架
+ * - 判断项目类型（后端/前端/全栈等）
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+// 检测规则配置
+const detectionRules = {
+    javascript: {
+        indicators: ['package.json'],
+        frameworks: {
+            // 后端框架
+            'express': { deps: ['express'], category: 'backend-api' },
+            'koa': { deps: ['koa'], category: 'backend-api' },
+            'fastify': { deps: ['fastify'], category: 'backend-api' },
+            'nestjs': { deps: ['@nestjs/core', '@nestjs/common'], category: 'backend-api' },
+            'hapi': { deps: ['@hapi/hapi'], category: 'backend-api' },
+            // 前端框架
+            'react': { deps: ['react'], category: 'frontend-spa' },
+            'vue': { deps: ['vue'], category: 'frontend-spa' },
+            'angular': { deps: ['@angular/core'], category: 'frontend-spa' },
+            'svelte': { deps: ['svelte'], category: 'frontend-spa' },
+            // 全栈框架
+            'nextjs': { deps: ['next'], category: 'fullstack' },
+            'nuxtjs': { deps: ['nuxt'], category: 'fullstack' },
+            'remix': { deps: ['@remix-run/react'], category: 'fullstack' },
+            'sveltekit': { deps: ['@sveltejs/kit'], category: 'fullstack' },
+            // 移动端
+            'react-native': { deps: ['react-native'], category: 'mobile' },
+            'expo': { deps: ['expo'], category: 'mobile' },
+            // 桌面端
+            'electron': { deps: ['electron'], category: 'desktop' },
+            'tauri': { deps: ['@tauri-apps/api'], category: 'desktop' },
+            // MCP 服务器
+            'mcp-server': { deps: ['@modelcontextprotocol/sdk'], category: 'library' }
+        }
+    },
+    python: {
+        indicators: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile'],
+        frameworks: {
+            'django': { deps: ['Django', 'django'], category: 'backend-api' },
+            'flask': { deps: ['Flask', 'flask'], category: 'backend-api' },
+            'fastapi': { deps: ['fastapi'], category: 'backend-api' },
+            'tornado': { deps: ['tornado'], category: 'backend-api' },
+            'jupyter': { deps: ['jupyter', 'notebook'], category: 'data-science' },
+            'pandas': { deps: ['pandas'], category: 'data-science' },
+            'numpy': { deps: ['numpy'], category: 'data-science' },
+            'click': { deps: ['click'], category: 'cli' },
+            'typer': { deps: ['typer'], category: 'cli' }
+        }
+    },
+    java: {
+        indicators: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+        frameworks: {
+            'spring-boot': { deps: ['spring-boot-starter'], category: 'backend-api' },
+            'spring-mvc': { deps: ['spring-webmvc'], category: 'backend-api' },
+            'android': { files: ['AndroidManifest.xml'], category: 'mobile' },
+            'quarkus': { deps: ['quarkus'], category: 'backend-api' },
+            'micronaut': { deps: ['micronaut'], category: 'backend-api' }
+        }
+    },
+    go: {
+        indicators: ['go.mod'],
+        frameworks: {
+            'gin': { imports: ['github.com/gin-gonic/gin'], category: 'backend-api' },
+            'echo': { imports: ['github.com/labstack/echo'], category: 'backend-api' },
+            'fiber': { imports: ['github.com/gofiber/fiber'], category: 'backend-api' },
+            'chi': { imports: ['github.com/go-chi/chi'], category: 'backend-api' },
+            'cobra': { imports: ['github.com/spf13/cobra'], category: 'cli' }
+        }
+    },
+    rust: {
+        indicators: ['Cargo.toml'],
+        frameworks: {
+            'actix': { deps: ['actix-web'], category: 'backend-api' },
+            'rocket': { deps: ['rocket'], category: 'backend-api' },
+            'axum': { deps: ['axum'], category: 'backend-api' },
+            'warp': { deps: ['warp'], category: 'backend-api' },
+            'clap': { deps: ['clap'], category: 'cli' }
+        }
+    },
+    cpp: {
+        indicators: ['CMakeLists.txt', 'Makefile', 'meson.build'],
+        frameworks: {
+            'qt': { files: ['*.pro', '*.qrc'], category: 'desktop' },
+            'boost': { files: ['boost'], category: 'library' }
+        }
+    },
+    php: {
+        indicators: ['composer.json'],
+        frameworks: {
+            'laravel': { deps: ['laravel/framework'], category: 'backend-api' },
+            'symfony': { deps: ['symfony/symfony'], category: 'backend-api' },
+            'codeigniter': { deps: ['codeigniter4/framework'], category: 'backend-api' }
+        }
+    },
+    ruby: {
+        indicators: ['Gemfile'],
+        frameworks: {
+            'rails': { deps: ['rails'], category: 'backend-api' },
+            'sinatra': { deps: ['sinatra'], category: 'backend-api' }
+        }
+    },
+    csharp: {
+        indicators: ['*.csproj', '*.sln'],
+        frameworks: {
+            'aspnet-core': { files: ['Program.cs', 'Startup.cs'], category: 'backend-api' },
+            'unity': { files: ['Assets', 'ProjectSettings'], category: 'desktop' }
+        }
+    }
+};
+/**
+ * 检测项目类型
+ */
+export function detectProjectType(projectRoot = process.cwd()) {
+    const indicators = [];
+    let detectedLanguage = 'unknown';
+    let detectedFramework;
+    let detectedCategory = 'unknown';
+    let confidence = 0;
+    // 遍历所有语言的检测规则
+    for (const [language, rule] of Object.entries(detectionRules)) {
+        // 检查语言特征文件是否存在
+        const languageIndicator = rule.indicators.find(indicator => {
+            const filePath = path.join(projectRoot, indicator);
+            return fs.existsSync(filePath);
+        });
+        if (languageIndicator) {
+            detectedLanguage = language;
+            indicators.push(languageIndicator);
+            confidence = 50; // 基础置信度
+            // 检测框架
+            const frameworkResult = detectFramework(projectRoot, language, rule);
+            if (frameworkResult) {
+                detectedFramework = frameworkResult.framework;
+                detectedCategory = frameworkResult.category;
+                confidence = frameworkResult.confidence;
+                indicators.push(...frameworkResult.indicators);
+            }
+            break; // 找到语言后停止
+        }
+    }
+    // 如果没有检测到语言，尝试通过文件扩展名判断
+    if (detectedLanguage === 'unknown') {
+        const languageByExtension = detectLanguageByExtension(projectRoot);
+        if (languageByExtension) {
+            detectedLanguage = languageByExtension.language;
+            confidence = languageByExtension.confidence;
+            indicators.push(...languageByExtension.indicators);
+        }
+    }
+    return {
+        language: detectedLanguage,
+        category: detectedCategory,
+        framework: detectedFramework,
+        confidence,
+        indicators
+    };
+}
+/**
+ * 检测框架
+ */
+function detectFramework(projectRoot, language, rule) {
+    for (const [framework, config] of Object.entries(rule.frameworks)) {
+        const indicators = [];
+        let matched = false;
+        // 检查依赖
+        if (config.deps) {
+            const deps = getDependencies(projectRoot, language);
+            if (deps && config.deps.some(dep => deps.includes(dep))) {
+                matched = true;
+                indicators.push(`dependency: ${config.deps.find(d => deps.includes(d))}`);
+            }
+        }
+        // 检查开发依赖
+        if (config.devDeps) {
+            const devDeps = getDevDependencies(projectRoot, language);
+            if (devDeps && config.devDeps.some(dep => devDeps.includes(dep))) {
+                matched = true;
+                indicators.push(`devDependency: ${config.devDeps.find(d => devDeps.includes(d))}`);
+            }
+        }
+        // 检查 imports
+        if (config.imports) {
+            const hasImport = checkImports(projectRoot, language, config.imports);
+            if (hasImport) {
+                matched = true;
+                indicators.push(`import: ${config.imports[0]}`);
+            }
+        }
+        // 检查特征文件
+        if (config.files) {
+            const hasFile = config.files.some(file => {
+                const filePath = path.join(projectRoot, file);
+                return fs.existsSync(filePath);
+            });
+            if (hasFile) {
+                matched = true;
+                indicators.push(`file: ${config.files[0]}`);
+            }
+        }
+        if (matched) {
+            return {
+                framework,
+                category: config.category,
+                confidence: 80,
+                indicators
+            };
+        }
+    }
+    return null;
+}
+/**
+ * 获取依赖列表
+ */
+function getDependencies(projectRoot, language) {
+    try {
+        if (language === 'javascript') {
+            const pkgPath = path.join(projectRoot, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                return Object.keys(pkg.dependencies || {});
+            }
+        }
+        else if (language === 'python') {
+            const reqPath = path.join(projectRoot, 'requirements.txt');
+            if (fs.existsSync(reqPath)) {
+                const content = fs.readFileSync(reqPath, 'utf-8');
+                return content.split('\n')
+                    .map(line => line.trim().split(/[=<>]/)[0])
+                    .filter(Boolean);
+            }
+        }
+        else if (language === 'rust') {
+            const cargoPath = path.join(projectRoot, 'Cargo.toml');
+            if (fs.existsSync(cargoPath)) {
+                const content = fs.readFileSync(cargoPath, 'utf-8');
+                // 简单解析 TOML（只提取依赖名）
+                const deps = content.match(/\[dependencies\]([\s\S]*?)(\[|$)/)?.[1];
+                if (deps) {
+                    return deps.split('\n')
+                        .map(line => line.trim().split(/\s*=/)[0])
+                        .filter(Boolean);
+                }
+            }
+        }
+        else if (language === 'go') {
+            const goModPath = path.join(projectRoot, 'go.mod');
+            if (fs.existsSync(goModPath)) {
+                const content = fs.readFileSync(goModPath, 'utf-8');
+                const requires = content.match(/require\s+\(([\s\S]*?)\)/)?.[1];
+                if (requires) {
+                    return requires.split('\n')
+                        .map(line => line.trim().split(/\s+/)[0])
+                        .filter(Boolean);
+                }
+            }
+        }
+    }
+    catch (error) {
+        // 忽略解析错误
+    }
+    return null;
+}
+/**
+ * 获取开发依赖列表
+ */
+function getDevDependencies(projectRoot, language) {
+    try {
+        if (language === 'javascript') {
+            const pkgPath = path.join(projectRoot, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                return Object.keys(pkg.devDependencies || {});
+            }
+        }
+    }
+    catch (error) {
+        // 忽略解析错误
+    }
+    return null;
+}
+/**
+ * 检查 imports
+ */
+function checkImports(projectRoot, language, imports) {
+    // 简化实现：检查 go.mod 或主文件
+    if (language === 'go') {
+        const goModPath = path.join(projectRoot, 'go.mod');
+        if (fs.existsSync(goModPath)) {
+            const content = fs.readFileSync(goModPath, 'utf-8');
+            return imports.some(imp => content.includes(imp));
+        }
+    }
+    return false;
+}
+/**
+ * 通过文件扩展名检测语言
+ */
+function detectLanguageByExtension(projectRoot) {
+    const extensionMap = {
+        '.js': 'javascript',
+        '.ts': 'javascript',
+        '.jsx': 'javascript',
+        '.tsx': 'javascript',
+        '.py': 'python',
+        '.java': 'java',
+        '.go': 'go',
+        '.rs': 'rust',
+        '.cpp': 'cpp',
+        '.cc': 'cpp',
+        '.c': 'cpp',
+        '.php': 'php',
+        '.rb': 'ruby',
+        '.cs': 'csharp'
+    };
+    try {
+        const srcDirs = ['src', 'lib', 'app', 'main'];
+        for (const dir of srcDirs) {
+            const dirPath = path.join(projectRoot, dir);
+            if (fs.existsSync(dirPath)) {
+                const files = fs.readdirSync(dirPath);
+                for (const file of files) {
+                    const ext = path.extname(file);
+                    if (extensionMap[ext]) {
+                        return {
+                            language: extensionMap[ext],
+                            confidence: 30,
+                            indicators: [`file extension: ${ext}`]
+                        };
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        // 忽略错误
+    }
+    return null;
+}

package/build/lib/response.js

@@ -20,6 +20,7 @@ export function okStructured(text, structuredContent, meta) {
             },
         ],
         structuredContent,
+        isError: false,
     };
     if (meta) {
         response._meta = meta;

package/build/lib/task-generator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 任务生成器
+ *
+ * 将分析任务转换为格式化的指导文本
+ */
+import type { AnalysisTask } from './analysis-tasks.js';
+import type { ProjectDetectionResult } from './project-detector.js';
+/**
+ * 生成完整的分析任务指导文本
+ */
+export declare function generateTaskGuide(detection: ProjectDetectionResult, tasks: AnalysisTask[], docsDir: string): string;