openmatrix 0.2.19 → 0.2.20

package/dist/test/context-analyzer.js

@@ -0,0 +1,778 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTestFrameworks = detectTestFrameworks;
+exports.detectProjectType = detectProjectType;
+exports.scanTestFiles = scanTestFiles;
+exports.scanSourceFiles = scanSourceFiles;
+exports.scanDirectory = scanDirectory;
+exports.inferSourceFile = inferSourceFile;
+exports.inferFileType = inferFileType;
+exports.extractExports = extractExports;
+exports.hasCorrespondingTest = hasCorrespondingTest;
+exports.inferTestTypes = inferTestTypes;
+exports.detectTestStyle = detectTestStyle;
+exports.detectFrontend = detectFrontend;
+exports.detectCoverageReport = detectCoverageReport;
+exports.performFullScan = performFullScan;
+// src/test/context-analyzer.ts
+/**
+ * 测试上下文分析器 - 项目代码扫描和框架检测
+ *
+ * 提供 CLI 和测试生成器共用的分析功能
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * 检测测试框架
+ */
+function detectTestFrameworks(projectRoot) {
+    const frameworks = [];
+    // 检测 package.json (Node.js/TypeScript)
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            detectNodeTestFrameworks(projectRoot, deps, frameworks);
+        }
+        catch {
+            // 忽略 JSON 解析错误
+        }
+    }
+    // 检测 Python 测试框架
+    detectPythonTestFrameworks(projectRoot, frameworks);
+    // 检测 Go 测试
+    const goModPath = path.join(projectRoot, 'go.mod');
+    if (fs.existsSync(goModPath)) {
+        frameworks.push({
+            framework: 'gotest',
+            isPrimary: frameworks.length === 0,
+            supportedTypes: ['unit', 'integration'],
+            commands: {
+                test: 'go test ./...',
+                testFile: 'go test <file>',
+                testCoverage: 'go test -cover ./...'
+            }
+        });
+    }
+    // 检测 Rust 测试
+    const cargoPath = path.join(projectRoot, 'Cargo.toml');
+    if (fs.existsSync(cargoPath)) {
+        frameworks.push({
+            framework: 'cargo-test',
+            isPrimary: frameworks.length === 0,
+            supportedTypes: ['unit', 'integration'],
+            commands: {
+                test: 'cargo test',
+                testCoverage: 'cargo tarpaulin'
+            }
+        });
+    }
+    // 检测 Java 测试框架
+    detectJavaTestFrameworks(projectRoot, frameworks);
+    // 如果没有检测到框架，标记为 unknown
+    if (frameworks.length === 0) {
+        frameworks.push({
+            framework: 'unknown',
+            isPrimary: true,
+            supportedTypes: [],
+            commands: { test: '' }
+        });
+    }
+    return frameworks;
+}
+/**
+ * 检测 Node.js 测试框架
+ */
+function detectNodeTestFrameworks(projectRoot, deps, frameworks) {
+    // Vitest
+    if (deps.vitest) {
+        const configFiles = ['vitest.config.ts', 'vitest.config.js', 'vite.config.ts', 'vite.config.js'];
+        const configFile = configFiles.find(f => fs.existsSync(path.join(projectRoot, f)));
+        frameworks.push({
+            framework: 'vitest',
+            version: deps.vitest,
+            configFile,
+            isPrimary: true,
+            supportedTypes: ['unit', 'integration'],
+            commands: {
+                test: 'vitest run',
+                testFile: 'vitest run <file>',
+                testCoverage: 'vitest run --coverage',
+                watch: 'vitest watch',
+                updateSnapshot: 'vitest run --update'
+            }
+        });
+    }
+    // Jest
+    if (deps.jest || deps['@types/jest']) {
+        const configFiles = ['jest.config.ts', 'jest.config.js', 'jest.config.json'];
+        const configFile = configFiles.find(f => fs.existsSync(path.join(projectRoot, f)));
+        frameworks.push({
+            framework: 'jest',
+            version: deps.jest || deps['@types/jest'],
+            configFile,
+            isPrimary: !frameworks.some(f => f.framework === 'vitest'),
+            supportedTypes: ['unit', 'integration'],
+            commands: {
+                test: 'jest',
+                testFile: 'jest <file>',
+                testCoverage: 'jest --coverage',
+                watch: 'jest --watch',
+                updateSnapshot: 'jest --updateSnapshot'
+            }
+        });
+    }
+    // Mocha
+    if (deps.mocha) {
+        const configFiles = ['.mocharc.json', '.mocharc.js', '.mocharc.yml'];
+        const configFile = configFiles.find(f => fs.existsSync(path.join(projectRoot, f)));
+        frameworks.push({
+            framework: 'mocha',
+            version: deps.mocha,
+            configFile,
+            isPrimary: !frameworks.some(f => f.isPrimary),
+            supportedTypes: ['unit', 'integration'],
+            commands: {
+                test: 'mocha',
+                testFile: 'mocha <file>',
+                testCoverage: 'nyc mocha'
+            }
+        });
+    }
+    // Playwright (E2E)
+    if (deps['@playwright/test']) {
+        const configFile = fs.existsSync(path.join(projectRoot, 'playwright.config.ts'))
+            ? 'playwright.config.ts'
+            : fs.existsSync(path.join(projectRoot, 'playwright.config.js'))
+                ? 'playwright.config.js'
+                : undefined;
+        frameworks.push({
+            framework: 'playwright',
+            version: deps['@playwright/test'],
+            configFile,
+            isPrimary: false,
+            supportedTypes: ['e2e', 'ui', 'visual', 'accessibility'],
+            commands: {
+                test: 'playwright test',
+                testFile: 'playwright test <file>',
+                watch: 'playwright test --ui'
+            }
+        });
+    }
+    // Cypress (E2E)
+    if (deps.cypress) {
+        const configFile = fs.existsSync(path.join(projectRoot, 'cypress.config.ts'))
+            ? 'cypress.config.ts'
+            : fs.existsSync(path.join(projectRoot, 'cypress.config.js'))
+                ? 'cypress.config.js'
+                : undefined;
+        frameworks.push({
+            framework: 'cypress',
+            version: deps.cypress,
+            configFile,
+            isPrimary: false,
+            supportedTypes: ['e2e', 'ui', 'integration'],
+            commands: {
+                test: 'cypress run',
+                testFile: 'cypress run --spec <file>',
+                watch: 'cypress open'
+            }
+        });
+    }
+}
+/**
+ * 检测 Python 测试框架
+ */
+function detectPythonTestFrameworks(projectRoot, frameworks) {
+    const requirementsPath = path.join(projectRoot, 'requirements.txt');
+    if (fs.existsSync(requirementsPath)) {
+        const requirements = fs.readFileSync(requirementsPath, 'utf-8');
+        if (requirements.includes('pytest')) {
+            frameworks.push({
+                framework: 'pytest',
+                isPrimary: frameworks.length === 0,
+                supportedTypes: ['unit', 'integration', 'api'],
+                commands: {
+                    test: 'pytest',
+                    testFile: 'pytest <file>',
+                    testCoverage: 'pytest --cov'
+                }
+            });
+        }
+        if (requirements.includes('unittest')) {
+            frameworks.push({
+                framework: 'unittest',
+                isPrimary: frameworks.length === 0 && !requirements.includes('pytest'),
+                supportedTypes: ['unit', 'integration'],
+                commands: {
+                    test: 'python -m unittest discover',
+                    testFile: 'python -m unittest <file>'
+                }
+            });
+        }
+    }
+    // 检测 pyproject.toml (Python)
+    const pyprojectPath = path.join(projectRoot, 'pyproject.toml');
+    if (fs.existsSync(pyprojectPath)) {
+        const pyproject = fs.readFileSync(pyprojectPath, 'utf-8');
+        if (pyproject.includes('pytest')) {
+            frameworks.push({
+                framework: 'pytest',
+                isPrimary: !frameworks.some(f => f.framework === 'pytest'),
+                supportedTypes: ['unit', 'integration', 'api'],
+                commands: {
+                    test: 'pytest',
+                    testFile: 'pytest <file>',
+                    testCoverage: 'pytest --cov'
+                }
+            });
+        }
+    }
+}
+/**
+ * 检测 Java 测试框架
+ */
+function detectJavaTestFrameworks(projectRoot, frameworks) {
+    const pomPath = path.join(projectRoot, 'pom.xml');
+    if (fs.existsSync(pomPath)) {
+        const pom = fs.readFileSync(pomPath, 'utf-8');
+        if (pom.includes('junit')) {
+            frameworks.push({
+                framework: 'junit',
+                isPrimary: frameworks.length === 0,
+                supportedTypes: ['unit', 'integration'],
+                commands: {
+                    test: 'mvn test',
+                    testFile: 'mvn test -Dtest=<class>'
+                }
+            });
+        }
+        if (pom.includes('testng')) {
+            frameworks.push({
+                framework: 'testng',
+                isPrimary: frameworks.length === 0 && !pom.includes('junit'),
+                supportedTypes: ['unit', 'integration'],
+                commands: {
+                    test: 'mvn test',
+                    testFile: 'mvn test -Dtest=<class>'
+                }
+            });
+        }
+    }
+    // 检测 Gradle (Java/Kotlin)
+    const gradlePath = path.join(projectRoot, 'build.gradle');
+    const gradleKtsPath = path.join(projectRoot, 'build.gradle.kts');
+    if (fs.existsSync(gradlePath) || fs.existsSync(gradleKtsPath)) {
+        const gradleFile = fs.existsSync(gradlePath) ? gradlePath : gradleKtsPath;
+        const gradle = fs.readFileSync(gradleFile, 'utf-8');
+        if (gradle.includes('junit') || gradle.includes('test')) {
+            frameworks.push({
+                framework: 'junit',
+                isPrimary: frameworks.length === 0,
+                supportedTypes: ['unit', 'integration'],
+                commands: {
+                    test: 'gradle test',
+                    testFile: 'gradle test --tests <class>'
+                }
+            });
+        }
+    }
+}
+/**
+ * 检测项目类型
+ */
+function detectProjectType(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    // Node.js/TypeScript 项目
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            // 前端框架检测
+            if (deps.react || deps['react-dom'])
+                return 'react';
+            if (deps.vue)
+                return 'vue';
+            if (deps['@angular/core'])
+                return 'angular';
+            if (deps.next)
+                return 'nextjs';
+            if (deps.nuxt)
+                return 'nuxt';
+            if (deps.svelte)
+                return 'svelte';
+            // TypeScript 检测
+            if (deps.typescript || fs.existsSync(path.join(projectRoot, 'tsconfig.json'))) {
+                return 'typescript';
+            }
+            return 'nodejs';
+        }
+        catch {
+            return 'nodejs';
+        }
+    }
+    // Python 项目
+    if (fs.existsSync(path.join(projectRoot, 'requirements.txt')) ||
+        fs.existsSync(path.join(projectRoot, 'pyproject.toml')) ||
+        fs.existsSync(path.join(projectRoot, 'setup.py'))) {
+        return 'python';
+    }
+    // Go 项目
+    if (fs.existsSync(path.join(projectRoot, 'go.mod'))) {
+        return 'go';
+    }
+    // Rust 项目
+    if (fs.existsSync(path.join(projectRoot, 'Cargo.toml'))) {
+        return 'rust';
+    }
+    // Java 项目
+    if (fs.existsSync(path.join(projectRoot, 'pom.xml')) ||
+        fs.existsSync(path.join(projectRoot, 'build.gradle')) ||
+        fs.existsSync(path.join(projectRoot, 'build.gradle.kts'))) {
+        return 'java';
+    }
+    // Flutter 项目
+    if (fs.existsSync(path.join(projectRoot, 'pubspec.yaml'))) {
+        const pubspec = fs.readFileSync(path.join(projectRoot, 'pubspec.yaml'), 'utf-8');
+        if (pubspec.includes('flutter'))
+            return 'flutter';
+        return 'dart';
+    }
+    return 'unknown';
+}
+/**
+ * 扫描测试文件
+ */
+function scanTestFiles(projectRoot, testDirs) {
+    const testFiles = [];
+    const testPatterns = [
+        /\.test\.(ts|tsx|js|jsx)$/,
+        /\.spec\.(ts|tsx|js|jsx)$/,
+        /_test\.(py)$/,
+        /test_.*\.py$/,
+        /_test\.go$/,
+        /Test.*\.java$/,
+        /.*Test\.java$/,
+        /.*Tests\.cs$/
+    ];
+    for (const testDir of testDirs) {
+        const fullPath = path.join(projectRoot, testDir);
+        if (!fs.existsSync(fullPath))
+            continue;
+        scanDirectory(fullPath, (filePath) => {
+            const relativePath = path.relative(projectRoot, filePath);
+            const fileName = path.basename(filePath);
+            // 检查是否匹配测试文件模式
+            const isTestFile = testPatterns.some(p => p.test(fileName));
+            if (!isTestFile)
+                return;
+            // 推断测试类型
+            let testType = 'unit';
+            if (relativePath.includes('e2e') || relativePath.includes('end-to-end')) {
+                testType = 'e2e';
+            }
+            else if (relativePath.includes('integration')) {
+                testType = 'integration';
+            }
+            else if (relativePath.includes('api')) {
+                testType = 'api';
+            }
+            else if (relativePath.includes('ui') || relativePath.includes('component')) {
+                testType = 'ui';
+            }
+            // 尝试推断关联的源文件
+            const sourceFile = inferSourceFile(filePath, projectRoot);
+            testFiles.push({
+                path: relativePath,
+                type: testType,
+                sourceFile,
+                lastModified: fs.statSync(filePath).mtime.toISOString()
+            });
+        });
+    }
+    return testFiles;
+}
+/**
+ * 扫描源文件
+ */
+function scanSourceFiles(projectRoot, sourceDirs, existingTests) {
+    const sourceFiles = [];
+    const sourcePatterns = [
+        /\.(ts|tsx)$/,
+        /\.(js|jsx)$/,
+        /\.py$/,
+        /\.go$/,
+        /\.java$/,
+        /\.rs$/,
+        /\.cs$/
+    ];
+    // 排除测试文件
+    const excludePatterns = [
+        /\.test\.(ts|tsx|js|jsx)$/,
+        /\.spec\.(ts|tsx|js|jsx)$/,
+        /_test\.(py)$/,
+        /test_.*\.py$/,
+        /_test\.go$/,
+        /Test.*\.java$/,
+        /__tests__/,
+        /tests?\//
+    ];
+    // 已有测试覆盖的源文件集合
+    const coveredSources = new Set();
+    for (const test of existingTests) {
+        if (test.sourceFile) {
+            coveredSources.add(test.sourceFile);
+        }
+    }
+    for (const sourceDir of sourceDirs) {
+        const fullPath = path.join(projectRoot, sourceDir);
+        if (!fs.existsSync(fullPath))
+            continue;
+        scanDirectory(fullPath, (filePath) => {
+            const relativePath = path.relative(projectRoot, filePath);
+            const fileName = path.basename(filePath);
+            // 排除测试文件
+            if (excludePatterns.some(p => p.test(relativePath) || p.test(fileName)))
+                return;
+            // 检查是否匹配源文件模式
+            const isSourceFile = sourcePatterns.some(p => p.test(fileName));
+            if (!isSourceFile)
+                return;
+            // 排除类型声明文件
+            if (fileName.endsWith('.d.ts'))
+                return;
+            // 推断文件类型
+            const fileType = inferFileType(relativePath);
+            // 提取导出
+            const exports = extractExports(filePath);
+            // 检查是否有对应的测试文件
+            const hasTest = coveredSources.has(relativePath) || hasCorrespondingTest(relativePath, existingTests);
+            // 推断建议的测试类型
+            const suggestedTestTypes = inferTestTypes(fileType, relativePath);
+            sourceFiles.push({
+                path: relativePath,
+                fileType,
+                exports,
+                hasTest,
+                suggestedTestTypes
+            });
+        });
+    }
+    return sourceFiles.filter(f => !f.hasTest);
+}
+/**
+ * 递归扫描目录
+ */
+function scanDirectory(dir, callback) {
+    const excludeDirs = ['node_modules', 'dist', 'build', '.git', '__pycache__', 'vendor', 'target'];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // 排除特定目录
+            if (excludeDirs.includes(entry.name))
+                continue;
+            scanDirectory(fullPath, callback);
+        }
+        else if (entry.isFile()) {
+            callback(fullPath);
+        }
+    }
+}
+/**
+ * 推断关联的源文件
+ */
+function inferSourceFile(testPath, projectRoot) {
+    const testFileName = path.basename(testPath);
+    const testDir = path.dirname(testPath);
+    // 移除测试后缀
+    let sourceName = testFileName
+        .replace(/\.test\.(ts|tsx|js|jsx)$/, '.$1')
+        .replace(/\.spec\.(ts|tsx|js|jsx)$/, '$1')
+        .replace(/_test\.py$/, '.py')
+        .replace(/test_(.*)\.py$/, '$1.py')
+        .replace(/_test\.go$/, '.go');
+    if (sourceName === testFileName)
+        return undefined;
+    // 在同目录或父目录寻找源文件
+    const possibleDirs = [
+        testDir,
+        path.join(testDir, '..'),
+        path.join(projectRoot, 'src'),
+        path.join(projectRoot, 'lib')
+    ];
+    for (const dir of possibleDirs) {
+        const sourcePath = path.join(dir, sourceName);
+        if (fs.existsSync(sourcePath)) {
+            return path.relative(projectRoot, sourcePath);
+        }
+    }
+    return undefined;
+}
+/**
+ * 推断文件类型
+ */
+function inferFileType(filePath) {
+    const fileName = path.basename(filePath);
+    const dirPath = path.dirname(filePath);
+    if (dirPath.includes('component') || fileName.includes('.tsx') || fileName.includes('.jsx')) {
+        return 'component';
+    }
+    if (dirPath.includes('service') || fileName.includes('service')) {
+        return 'service';
+    }
+    if (dirPath.includes('util') || dirPath.includes('utils') || fileName.includes('util')) {
+        return 'util';
+    }
+    if (fileName.includes('.class.') || fileName.match(/[A-Z][a-z]+\.ts$/)) {
+        return 'class';
+    }
+    if (dirPath.includes('api') || dirPath.includes('route')) {
+        return 'module';
+    }
+    return 'module';
+}
+/**
+ * 提取导出（简化版）
+ */
+function extractExports(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const exports = [];
+        // 提取 export function/class/const
+        const exportPatterns = [
+            /export\s+function\s+(\w+)/g,
+            /export\s+class\s+(\w+)/g,
+            /export\s+const\s+(\w+)/g,
+            /export\s+async\s+function\s+(\w+)/g,
+            /export\s+\{[^}]*\}/g
+        ];
+        for (const pattern of exportPatterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                if (match[1]) {
+                    exports.push(match[1]);
+                }
+                else {
+                    // 解析 export { ... }
+                    const items = match[0].match(/\w+/g);
+                    if (items) {
+                        exports.push(...items.filter(i => i !== 'export'));
+                    }
+                }
+            }
+        }
+        // Python def/class
+        if (filePath.endsWith('.py')) {
+            const pyPatterns = [
+                /^def\s+(\w+)/gm,
+                /^class\s+(\w+)/gm
+            ];
+            for (const pattern of pyPatterns) {
+                let match;
+                while ((match = pattern.exec(content)) !== null) {
+                    if (match[1] && !match[1].startsWith('_')) {
+                        exports.push(match[1]);
+                    }
+                }
+            }
+        }
+        return exports.slice(0, 10);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 检查是否有对应的测试文件
+ */
+function hasCorrespondingTest(sourcePath, existingTests) {
+    const sourceFileName = path.basename(sourcePath);
+    // 生成可能的测试文件名
+    const possibleTestNames = [
+        sourceFileName.replace(/\.(ts|tsx|js|jsx)$/, '.test.$1'),
+        sourceFileName.replace(/\.(ts|tsx|js|jsx)$/, '.spec.$1'),
+        sourceFileName.replace(/\.py$/, '_test.py'),
+        sourceFileName.replace(/\.py$/, 'test_' + sourceFileName.replace('.py', '') + '.py'),
+        sourceFileName.replace(/\.go$/, '_test.go')
+    ];
+    return existingTests.some(t => possibleTestNames.includes(path.basename(t.path)));
+}
+/**
+ * 推断建议的测试类型
+ */
+function inferTestTypes(fileType, filePath) {
+    const types = ['unit'];
+    if (fileType === 'component') {
+        types.push('ui');
+    }
+    if (fileType === 'service') {
+        types.push('integration');
+    }
+    if (filePath.includes('api') || filePath.includes('route')) {
+        types.push('api');
+    }
+    return types;
+}
+/**
+ * 检测测试风格
+ */
+function detectTestStyle(projectRoot, existingTests) {
+    if (existingTests.length === 0)
+        return undefined;
+    // 读取第一个测试文件分析风格
+    const sampleTest = existingTests[0];
+    const testPath = path.join(projectRoot, sampleTest.path);
+    try {
+        const content = fs.readFileSync(testPath, 'utf-8');
+        // 命名约定
+        const hasDescribeIt = content.includes('describe(') && content.includes('it(');
+        const hasTest = content.includes('test(');
+        const namingConvention = hasDescribeIt && hasTest ? 'mixed' :
+            hasDescribeIt ? 'describe-it' : 'test';
+        let assertionLibrary = 'expect';
+        if (content.includes('assert('))
+            assertionLibrary = 'assert';
+        if (content.includes('should('))
+            assertionLibrary = 'should';
+        if (content.includes('chai'))
+            assertionLibrary = 'chai';
+        // TypeScript/JSX
+        const usesTypeScript = testPath.endsWith('.ts') || testPath.endsWith('.tsx');
+        const usesJSX = testPath.endsWith('.tsx') || testPath.endsWith('.jsx');
+        // 文件后缀
+        const fileSuffix = path.extname(testPath);
+        // 文件位置
+        const testDir = path.dirname(sampleTest.path);
+        const sourceDir = sampleTest.sourceFile ? path.dirname(sampleTest.sourceFile) : '';
+        const fileLocation = testDir === sourceDir || testDir === '__tests__' ? 'adjacent' : 'separate';
+        return {
+            namingConvention,
+            assertionLibrary,
+            usesTypeScript,
+            usesJSX,
+            fileSuffix,
+            fileLocation
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 检测是否有前端项目
+ */
+function detectFrontend(projectRoot, projectType) {
+    const frontendTypes = ['react', 'vue', 'angular', 'nextjs', 'nuxt', 'svelte', 'flutter'];
+    const isFrontend = frontendTypes.includes(projectType);
+    // 检查是否有 UI 组件目录
+    const componentDirs = ['components', 'src/components', 'pages', 'src/pages', 'views', 'src/views'];
+    const hasUIComponents = componentDirs.some(d => fs.existsSync(path.join(projectRoot, d)));
+    return { isFrontend, hasUIComponents };
+}
+/**
+ * 检测覆盖率报告
+ */
+function detectCoverageReport(projectRoot) {
+    const coveragePaths = [
+        'coverage/coverage-summary.json',
+        'coverage/lcov-report/lcov.info',
+        '.nyc_output/out.json',
+        'coverage.json'
+    ];
+    for (const coveragePath of coveragePaths) {
+        const fullPath = path.join(projectRoot, coveragePath);
+        if (fs.existsSync(fullPath)) {
+            try {
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                const data = JSON.parse(content);
+                if (data.total) {
+                    return {
+                        total: data.total.lines?.pct || data.total,
+                        files: []
+                    };
+                }
+            }
+            catch {
+                // 忽略解析错误
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * 执行完整扫描并返回结果
+ */
+function performFullScan(projectRoot, target) {
+    // 确定扫描目录
+    const testDirs = ['tests', 'test', '__tests__', 'spec', 'src/__tests__', 'cypress/e2e', 'e2e'];
+    const sourceDirs = target ? [target] : ['src', 'lib', 'app', 'packages'];
+    // 检测测试框架
+    const frameworks = detectTestFrameworks(projectRoot);
+    // 检测项目类型
+    const projectType = detectProjectType(projectRoot);
+    // 扫描测试文件
+    const existingTests = scanTestFiles(projectRoot, testDirs);
+    // 扫描源文件
+    const uncoveredSources = scanSourceFiles(projectRoot, sourceDirs, existingTests);
+    // 检测前端信息
+    const frontendInfo = detectFrontend(projectRoot, projectType);
+    // 检测测试风格
+    const testStyle = detectTestStyle(projectRoot, existingTests);
+    // 检测覆盖率报告
+    const coverageReport = detectCoverageReport(projectRoot);
+    return {
+        timestamp: new Date().toISOString(),
+        projectRoot,
+        target: target || 'all',
+        frameworks,
+        existingTests,
+        uncoveredSources,
+        projectType,
+        isFrontend: frontendInfo.isFrontend,
+        hasUIComponents: frontendInfo.hasUIComponents,
+        coverageReport,
+        testStyle,
+        summary: {
+            frameworkCount: frameworks.length,
+            existingTestCount: existingTests.length,
+            uncoveredSourceCount: uncoveredSources.length,
+            hasTestConfig: frameworks.some(f => f.configFile),
+            hasCoverageConfig: frameworks.some(f => f.commands.testCoverage)
+        }
+    };
+}