ai-worktool 1.0.7

package/dist/tools/project.js

@@ -0,0 +1,541 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProjectConfig = detectProjectConfig;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+/**
+ * 检测项目配置信息
+ */
+async function detectProjectConfig(projectRoot, defaultConfig) {
+    defaultConfig = defaultConfig || {};
+    const config = {
+        projectRoot: defaultConfig.projectRoot || projectRoot,
+        projectType: defaultConfig.projectType || 'unknown',
+        packageManager: defaultConfig.packageManager || 'unknown',
+        testFramework: defaultConfig.testFramework || 'unknown',
+        srcDir: defaultConfig.srcDir || undefined,
+        testDir: defaultConfig.testDir || undefined,
+        coverageDir: defaultConfig.coverageDir || undefined,
+        testFilePatterns: defaultConfig.testFilePatterns || [],
+        languages: defaultConfig.languages || [],
+        testConfigFile: defaultConfig.testConfigFile || undefined,
+        isInstalled: defaultConfig.isInstalled || undefined
+    };
+    // 首先检查项目是否已安装
+    await checkProjectInstalled(projectRoot, config);
+    // 只有项目已安装的情况下才进行其他检测
+    if (config.isInstalled) {
+        // 检测包管理工具
+        await detectPackageManager(projectRoot, config);
+        // 检测使用的开发语言
+        await detectLanguages(projectRoot, config);
+        // 检测源代码目录
+        await detectSrcDir(projectRoot, config);
+        // 检测测试相关配置
+        await detectTestConfig(projectRoot, config);
+        // 检测项目类型（前端/后端/全栈）
+        await detectProjectType(projectRoot, config);
+        // 检测框架信息
+        await detectFramework(projectRoot, config);
+    }
+    return config;
+}
+/**
+ * 检查项目是否已安装
+ * 项目已安装的标志：存在package.json和node_modules目录
+ */
+async function checkProjectInstalled(projectRoot, config) {
+    // 检查package.json是否存在
+    const hasPackageJson = await fileExists(path_1.default.join(projectRoot, 'package.json'));
+    // 检查node_modules目录是否存在
+    const hasNodeModules = await directoryExists(path_1.default.join(projectRoot, 'node_modules'));
+    // 两个条件都满足才认为项目已安装
+    config.isInstalled = hasPackageJson && hasNodeModules;
+}
+/**
+ * 检测包管理工具
+ */
+async function detectPackageManager(projectRoot, config) {
+    const lockFiles = [
+        { name: 'package-lock.json', manager: 'npm' },
+        { name: 'yarn.lock', manager: 'yarn' },
+        { name: 'pnpm-lock.yaml', manager: 'pnpm' },
+        { name: 'bun.lockb', manager: 'bun' }
+    ];
+    for (const lockFile of lockFiles) {
+        const lockFilePath = path_1.default.join(projectRoot, lockFile.name);
+        if (await fileExists(lockFilePath)) {
+            config.packageManager = lockFile.manager;
+            return;
+        }
+    }
+    // config.packageManager = 'unknown';
+}
+/**
+ * 检测开发语言 - 排除node_modules和隐藏目录
+ */
+async function detectLanguages(projectRoot, config) {
+    const languages = [];
+    // 检查TypeScript配置文件（不受目录过滤影响）
+    const tsConfigPath = path_1.default.join(projectRoot, 'tsconfig.json');
+    if (await fileExists(tsConfigPath)) {
+        languages.push('typescript');
+    }
+    // 检查是否有JavaScript文件（排除node_modules和隐藏目录）
+    const hasJsFiles = await hasFilesWithExtensionFiltered(projectRoot, '.js', (dir) => dir !== 'node_modules' && !dir.startsWith('.'));
+    if (hasJsFiles) {
+        languages.push('javascript');
+    }
+    // 检查是否有CoffeeScript文件（排除node_modules和隐藏目录）
+    const hasCoffeeFiles = await hasFilesWithExtensionFiltered(projectRoot, '.coffee', (dir) => dir !== 'node_modules' && !dir.startsWith('.'));
+    if (hasCoffeeFiles) {
+        languages.push('coffeescript');
+    }
+    config.languages = languages;
+}
+/**
+ * 检测源代码目录
+ */
+async function detectSrcDir(projectRoot, config) {
+    const possibleSrcDirs = ['src', 'lib', 'app', 'source'];
+    for (const dir of possibleSrcDirs) {
+        const dirPath = path_1.default.join(projectRoot, dir);
+        if (await directoryExists(dirPath)) {
+            config.srcDir = dir;
+            return;
+        }
+    }
+    config.srcDir = '';
+}
+/**
+ * 检测测试相关配置
+ */
+async function detectTestConfig(projectRoot, config) {
+    // 检测测试框架
+    const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+    if (await fileExists(packageJsonPath)) {
+        const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonPath, 'utf8'));
+        const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        // 检测测试框架
+        if (dependencies.jest) {
+            config.testFramework = 'jest';
+        }
+        else if (dependencies.mocha) {
+            config.testFramework = 'mocha';
+        }
+        else if (dependencies.vitest) {
+            config.testFramework = 'vitest';
+        }
+        else if (dependencies.jasmine) {
+            config.testFramework = 'jasmine';
+        }
+        else if (dependencies.cypress) {
+            config.testFramework = 'cypress';
+        }
+        else if (dependencies['@playwright/test']) {
+            config.testFramework = 'playwright';
+        }
+    }
+    // 检测测试目录
+    const possibleTestDirs = ['test', 'tests', '__tests__', 'spec', 'specs'];
+    for (const dir of possibleTestDirs) {
+        const dirPath = path_1.default.join(projectRoot, dir);
+        if (await directoryExists(dirPath)) {
+            config.testDir = dir;
+            break;
+        }
+    }
+    // 检测覆盖率报告目录
+    const possibleCoverageDirs = ['coverage', 'test-reports', 'reports'];
+    for (const dir of possibleCoverageDirs) {
+        const dirPath = path_1.default.join(projectRoot, dir);
+        if (await directoryExists(dirPath)) {
+            config.coverageDir = dir;
+            break;
+        }
+    }
+    // 检测测试框架配置文件
+    const testFrameworkConfigFiles = [
+        { framework: 'jest', files: ['jest.config.js', 'jest.config.ts', 'jest.config.json', '.jestrc.js', '.jestrc'] },
+        { framework: 'mocha', files: ['mocha.config.js', 'mocha.config.ts', '.mocharc.js', '.mocharc.json', 'mocha.opts'] },
+        { framework: 'vitest', files: ['vitest.config.js', 'vitest.config.ts', 'vite.config.js', 'vite.config.ts'] },
+        { framework: 'jasmine', files: ['jasmine.json', 'jasmine.config.js'] },
+        { framework: 'cypress', files: ['cypress.config.js', 'cypress.config.ts', 'cypress.json'] },
+        { framework: 'playwright', files: ['playwright.config.js', 'playwright.config.ts'] }
+    ];
+    // 如果已经检测到测试框架，优先检测对应框架的配置文件
+    if (config.testFramework !== 'unknown') {
+        const frameworkConfig = testFrameworkConfigFiles.find((item) => item.framework === config.testFramework);
+        if (frameworkConfig) {
+            for (const file of frameworkConfig.files) {
+                const filePath = path_1.default.join(projectRoot, file);
+                if (await fileExists(filePath)) {
+                    config.testConfigFile = file;
+                    break;
+                }
+            }
+        }
+    }
+    // 如果未检测到特定框架的配置文件，检测所有可能的配置文件
+    for (const framework of testFrameworkConfigFiles) {
+        for (const file of framework.files) {
+            const filePath = path_1.default.join(projectRoot, file);
+            if (await fileExists(filePath)) {
+                config.testConfigFile = file;
+                // 如果找到了配置文件但尚未确定测试框架，可以根据配置文件推断
+                if (config.testFramework === 'unknown') {
+                    config.testFramework = framework.framework;
+                }
+                break;
+            }
+        }
+    }
+    // 检测测试文件模式（优化部分）
+    config.testFilePatterns = [];
+    // 定义可能的测试文件模式模板
+    const patternTemplates = [
+        `*.test.{{ext}}`,
+        `*.spec.{{ext}}`,
+        `__tests__/**/*.{{ext}}`,
+        `test/**/*.{{ext}}`,
+        `tests/**/*.{{ext}}`,
+        `spec/**/*.{{ext}}`,
+        `specs/**/*.{{ext}}`
+    ];
+    // 根据项目语言生成对应扩展名的模式
+    const extensions = new Set();
+    if (config.languages.includes('javascript')) {
+        extensions.add('js');
+    }
+    if (config.languages.includes('typescript')) {
+        extensions.add('ts');
+    }
+    if (config.languages.includes('coffeescript')) {
+        extensions.add('coffee');
+    }
+    // 默认为js（如果没有检测到语言）
+    if (extensions.size === 0) {
+        extensions.add('js');
+    }
+    // 生成基础模式集合
+    const basePatterns = new Set();
+    extensions.forEach((ext) => {
+        patternTemplates.forEach((tpl) => {
+            basePatterns.add(tpl.replace('{{ext}}', ext));
+        });
+    });
+    // 1. 优先从package.json的test脚本中提取模式
+    if (await fileExists(packageJsonPath)) {
+        const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonPath, 'utf8'));
+        if (packageJson.scripts && packageJson.scripts.test) {
+            const testScript = packageJson.scripts.test;
+            // 从脚本中提取符合基础模式的路径
+            Array.from(basePatterns).forEach((pattern) => {
+                // 简单匹配脚本中是否包含该模式（考虑可能有引号包裹的情况）
+                if (testScript.includes(pattern) ||
+                    testScript.includes(`'${pattern}'`) ||
+                    testScript.includes(`"${pattern}"`)) {
+                    config.testFilePatterns.push(pattern);
+                }
+            });
+        }
+    }
+    // 2. 如果脚本中没有找到，检测实际存在的测试文件模式
+    if (config.testFilePatterns.length === 0 && config.testDir) {
+        const testDirPath = path_1.default.join(projectRoot, config.testDir);
+        if (await directoryExists(testDirPath)) {
+            // 检测测试目录中实际存在的文件模式
+            const detectedPatterns = await detectExistingTestPatterns(testDirPath, projectRoot, extensions);
+            config.testFilePatterns = detectedPatterns;
+        }
+    }
+    // 3. 如果仍未找到，使用基础模式
+    if (config.testFilePatterns.length === 0) {
+        config.testFilePatterns = Array.from(basePatterns);
+    }
+}
+/**
+ * 检测实际存在的测试文件模式
+ */
+async function detectExistingTestPatterns(testDir, projectRoot, extensions) {
+    const patterns = new Set();
+    const relativeTestDir = path_1.default.relative(projectRoot, testDir);
+    // 递归检查测试目录中的文件
+    async function checkDir(currentDir) {
+        const entries = await promises_1.default.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(currentDir, entry.name);
+            if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+                await checkDir(fullPath);
+            }
+            else if (entry.isFile()) {
+                // 检查文件是否匹配测试文件命名规范
+                const extMatch = entry.name.match(/\.([^.]+)$/);
+                if (extMatch && extensions.has(extMatch[1])) {
+                    const fileName = entry.name.replace(/\.[^.]+$/, '');
+                    if (fileName.endsWith('.test') || fileName.endsWith('.spec')) {
+                        // 生成对应的glob模式
+                        const dirPart = path_1.default.relative(testDir, currentDir);
+                        const patternDir = dirPart ? `${dirPart}/**` : '**';
+                        const pattern = `${relativeTestDir}/${patternDir}/*.${extMatch[1]}`;
+                        patterns.add(pattern);
+                    }
+                }
+            }
+        }
+    }
+    await checkDir(testDir);
+    return Array.from(patterns);
+}
+// 项目特征配置
+const projectFeatures = {
+    frontend: {
+        dependencies: [
+            'react',
+            'vue',
+            'angular',
+            'svelte',
+            'preact',
+            'react-dom',
+            'vue-router',
+            'next',
+            'nuxt',
+            'gatsby',
+            'webpack',
+            'vite',
+            'rollup',
+            'parcel',
+            'tailwindcss',
+            'styled-components',
+            'emotion',
+            'sass',
+            'less'
+        ],
+        configFiles: [
+            'webpack.config.js',
+            'vite.config.js',
+            'rollup.config.js',
+            'babel.config.js',
+            'tsconfig.json',
+            '.eslintrc.js',
+            'next.config.js',
+            'nuxt.config.js',
+            'gatsby-config.js'
+        ],
+        directories: ['src/components', 'src/pages', 'src/views', 'public', 'assets']
+    },
+    backend: {
+        dependencies: [
+            'express',
+            'koa',
+            'nestjs',
+            'fastify',
+            'hapi',
+            'koa-router',
+            'express-router',
+            'mongoose',
+            'sequelize',
+            'typeorm',
+            'prisma',
+            'pg',
+            'mysql',
+            'mongodb',
+            'redis',
+            'nodemailer',
+            'passport',
+            'jsonwebtoken'
+        ],
+        configFiles: [
+            'server.js',
+            'app.js',
+            'nest-cli.json',
+            'prisma/schema.prisma',
+            '.env',
+            '.env.example',
+            'database.json'
+        ],
+        directories: ['src/controllers', 'src/services', 'src/routes', 'src/middleware', 'prisma']
+    },
+    cli: {
+        dependencies: ['commander', 'yargs', 'inquirer', 'cli-table', 'chalk', 'ora', 'figlet', 'meow', 'arg'],
+        configFiles: ['cli.js', 'bin/cli.js'],
+        directories: ['bin', 'src/commands']
+    }
+};
+/**
+ * 异步读取package.json依赖
+ * @returns 依赖和开发依赖数组
+ */
+async function getDependencies(projectRoot) {
+    const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+    if (!(await fileExists(packageJsonPath))) {
+        return { dependencies: [], devDependencies: [] };
+    }
+    try {
+        const packageJsonContent = await promises_1.default.readFile(packageJsonPath, 'utf8');
+        const packageJson = JSON.parse(packageJsonContent);
+        return {
+            dependencies: packageJson.dependencies ? Object.keys(packageJson.dependencies) : [],
+            devDependencies: packageJson.devDependencies ? Object.keys(packageJson.devDependencies) : []
+        };
+    }
+    catch (err) {
+        console.error('读取package.json时出错:', err);
+        return { dependencies: [], devDependencies: [] };
+    }
+}
+/**
+ * 异步计算项目类型匹配分数
+ * @param type 项目类型
+ * @returns 匹配分数
+ */
+async function calculateScore(projectRoot, type) {
+    const features = projectFeatures[type];
+    const { dependencies, devDependencies } = await getDependencies(projectRoot);
+    let score = 0;
+    // 检查依赖匹配
+    const allDeps = [...dependencies, ...devDependencies];
+    features.dependencies.forEach((dep) => {
+        if (allDeps.some((d) => d.includes(dep))) {
+            score += 3; // 依赖权重较高
+        }
+    });
+    // 检查配置文件匹配（并行处理）
+    const configFileChecks = features.configFiles.map((file) => fileExists(path_1.default.join(process.cwd(), file)));
+    const configFileResults = await Promise.all(configFileChecks);
+    score += configFileResults.filter(Boolean).length * 2; // 配置文件权重中等
+    // 检查目录结构匹配（并行处理）
+    const directoryChecks = features.directories.map((dir) => directoryExists(path_1.default.join(process.cwd(), dir)));
+    const directoryResults = await Promise.all(directoryChecks);
+    score += directoryResults.filter(Boolean).length * 1; // 目录权重较低
+    return score;
+}
+/**
+ * 异步检测项目类型
+ * @returns 检测结果
+ */
+async function detectProjectType(projectRoot, config) {
+    // 并行计算各类型分数
+    const [frontendScore, backendScore, cliScore] = await Promise.all([
+        calculateScore(projectRoot, 'frontend'),
+        calculateScore(projectRoot, 'backend'),
+        calculateScore(projectRoot, 'cli')
+    ]);
+    // 计算分数
+    const scores = {
+        frontend: frontendScore,
+        backend: backendScore,
+        cli: cliScore
+    };
+    // 判断是否为全栈项目
+    const isFullstack = frontendScore > 0 && backendScore > 0 && Math.abs(frontendScore - backendScore) < frontendScore * 0.5;
+    if (isFullstack) {
+        config.projectType = 'fullstack';
+    }
+    // 确定最高分数的项目类型
+    const maxScore = Math.max(frontendScore, backendScore, cliScore);
+    if (maxScore === 0) {
+        config.projectType = 'unknown';
+    }
+    if (maxScore === frontendScore) {
+        config.projectType = 'frontend';
+    }
+    else if (maxScore === backendScore) {
+        config.projectType = 'backend';
+    }
+    else {
+        config.projectType = 'cli';
+    }
+}
+/**
+ * 检测框架信息
+ */
+async function detectFramework(projectRoot, config) {
+    const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+    if (await fileExists(packageJsonPath)) {
+        const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonPath, 'utf8'));
+        const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        // 检测前端框架
+        if (dependencies.react || dependencies['react-dom']) {
+            config.framework = 'react';
+        }
+        else if (dependencies.vue) {
+            config.framework = 'vue';
+        }
+        else if (dependencies.angular || dependencies['@angular/core']) {
+            config.framework = 'angular';
+        }
+        else if (dependencies.svelte) {
+            config.framework = 'svelte';
+        }
+        // 检测后端框架
+        else if (dependencies.express) {
+            config.framework = 'express';
+        }
+        else if (dependencies.nestjs || dependencies['@nestjs/core']) {
+            config.framework = 'nestjs';
+        }
+        else if (dependencies.koa) {
+            config.framework = 'koa';
+        }
+        else if (dependencies.fastify) {
+            config.framework = 'fastify';
+        }
+    }
+}
+/**
+ * 辅助函数：检查文件是否存在
+ */
+async function fileExists(filePath) {
+    try {
+        const stats = await promises_1.default.stat(filePath);
+        return stats.isFile();
+    }
+    catch (err) {
+        return false;
+    }
+}
+/**
+ * 辅助函数：检查目录是否存在
+ */
+async function directoryExists(dirPath) {
+    try {
+        const stats = await promises_1.default.stat(dirPath);
+        return stats.isDirectory();
+    }
+    catch (err) {
+        return false;
+    }
+}
+/**
+ * 辅助函数：检查是否有特定扩展名的文件（带目录过滤功能）
+ * @param rootDir 根目录
+ * @param extension 文件扩展名
+ * @param dirFilter 目录过滤函数，返回true表示需要处理该目录
+ */
+async function hasFilesWithExtensionFiltered(rootDir, extension, dirFilter) {
+    try {
+        const entries = await promises_1.default.readdir(rootDir, { withFileTypes: true });
+        for (const entry of entries) {
+            // 检查文件
+            if (entry.isFile() && entry.name.endsWith(extension)) {
+                return true;
+            }
+            // 检查目录（应用过滤条件）
+            if (entry.isDirectory() && dirFilter(entry.name)) {
+                const hasFiles = await hasFilesWithExtensionFiltered(path_1.default.join(rootDir, entry.name), extension, dirFilter);
+                if (hasFiles) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    catch (err) {
+        return false;
+    }
+}
+//# sourceMappingURL=project.js.map