@chen_258/audit-tool 1.0.5 → 1.1.1

package/dist/audit/index.js

@@ -36,7 +36,7 @@ class Audit {
             return Promise.resolve(this.cachedResult);
         }
         return new Promise((resolve, reject) => {
-            const childProcess = spawn('npm', ['audit', '--json'], {
+            const childProcess = spawn('npm', ['audit', '--json', '--no-workspaces'], {
                 cwd: this.inputPath,
                 stdio: ['pipe', 'pipe', 'pipe'],
                 shell: true,
@@ -229,3 +229,4 @@ export async function audit(inputPath, outputPath) {
     process.stderr.write('审计函数执行完成，程序可以继续...\n');
     return report;
 }
+export { Audit };

package/dist/entry/index.js

@@ -1,6 +1,9 @@
-import { createPageJson, getPageJson } from '../package-json/index.js';
+import { createPageJson, getPageJsonWithPaths } from '../package-json/index.js';
 import { createWorkDir, deleteWorkDir } from '../file/index.js';
-import { audit } from '../audit/index.js';
+import { Audit } from '../audit/index.js';
+import { generateSummaryReport } from '../report-generator/index.js';
+import path from 'path';
+import fs from 'fs';
 /**
  * CLI 入口 — 独立运行模式
  * 直接在终端执行安全审计，结果输出为 Markdown 文件
@@ -9,18 +12,48 @@ import { audit } from '../audit/index.js';
  */
 async function main(url) {
     const workDir = await createWorkDir(); // 创建临时目录
-    // 获取本地或者远程工程文件的package.json
-    const resJson = await getPageJson(url);
-    //在工作目录生成临时的package.json（使用 pnpm 生成 lock 文件）
-    await createPageJson(workDir, resJson);
-    //安全审计 进入临时目录 执行 pnpm audit 执行安全审计
-    await audit(workDir, './audit.md');
+    // 获取本地或者远程工程文件的package.json（标准化扫描结果）
+    const scanResult = await getPageJsonWithPaths(url);
+    const { packages: packagesInfo, detectedTypes } = scanResult;
+    console.log(`\n📁 检测到工程类型: ${detectedTypes.join(', ')}`);
+    console.log(`📦 发现 ${packagesInfo.length} 个 package.json`);
+    // 在工作目录生成临时的 package.json
+    const packages = packagesInfo.map(pkg => pkg.content);
+    await createPageJson(workDir, packages);
+    // 获取 workDir 下的所有子目录（每个子目录对应一个 package）
+    const subDirs = fs.readdirSync(workDir).filter(item => {
+        const itemPath = path.join(workDir, item);
+        return fs.statSync(itemPath).isDirectory();
+    });
+    // 对每个子目录进行安全审计，并收集审计结果
+    const auditResults = [];
+    for (let i = 0; i < subDirs.length; i++) {
+        const subDir = subDirs[i];
+        const subDirPath = path.join(workDir, subDir);
+        console.log(`\n🔍 开始审计: ${subDir}`);
+        // 创建 Audit 实例并获取审计结果（不生成单独文件）
+        const auditInstance = new Audit(subDirPath, '');
+        const auditResult = JSON.parse(await auditInstance.command());
+        // 获取对应的 package.json 路径和工程类型
+        const packageJsonPath = packagesInfo[i]?.path || '';
+        const projectType = packagesInfo[i]?.projectType || 'unknown';
+        auditResults.push({
+            subDir,
+            packageJsonPath,
+            projectType,
+            auditResult
+        });
+    }
+    // 生成汇总报告到项目根目录
+    console.log(`\n📊 生成汇总报告...`);
+    const summaryPath = path.join(process.cwd(), 'audit-summary.md');
+    await generateSummaryReport(auditResults, summaryPath);
     await deleteWorkDir(workDir); // 删除临时目录
 }
 // 测试本地项目
-main('https://raw.githubusercontent.com/djdjjsfsks/manage/main').then(() => {
-    console.log('✅ 程序执行完毕');
+main('https://raw.githubusercontent.com/lerna/lerna/refs/heads/main').then(() => {
+    console.log('\n✅ 程序执行完毕');
 }).catch((error) => {
-    console.error('❌ 程序执行失败:', error.message);
+    console.error('\n❌ 程序执行失败:', error.message);
     process.exit(1);
 });

package/dist/factory/detector.js

@@ -0,0 +1,77 @@
+/**
+ * 各架构类型的配置文件标识
+ * detector 通过检查这些文件是否存在来判断工程类型
+ */
+const DETECTION_MARKERS = {
+    'lerna.json': 'lerna',
+    'nx.json': 'nx',
+    'turbo.json': 'turborepo',
+    'rush.json': 'rush',
+    'pnpm-workspace.yaml': 'workspaces',
+};
+/**
+ * 工程类型检测器
+ *
+ * 通过读取根目录下的配置文件来判断 Monorepo 架构类型。
+ * 支持本地路径和远程 URL 两种来源。
+ *
+ * 检测优先级：
+ * 1. 检查各架构的专属配置文件（lerna.json, nx.json, turbo.json, rush.json）
+ * 2. 检查 pnpm-workspace.yaml
+ * 3. 检查根 package.json 中是否包含 workspaces 字段
+ * 4. 若检测到多种类型，自动判定为 hybrid（混合架构）
+ * 5. 若均未检测到，判定为 single（单项目）
+ */
+export class ProjectDetector {
+    /**
+     * 检测工程类型
+     * @param rootPath 项目根路径（本地路径或远程 URL）
+     * @param readFileFn 读取文件内容的函数（支持本地和远程）
+     * @param rootPackageJson 根目录 package.json 的解析内容
+     * @returns 检测到的工程类型数组
+     */
+    static async detect(rootPath, readFileFn, rootPackageJson) {
+        const detectedTypes = [];
+        // 1. 通过配置文件标识检测架构类型
+        for (const [fileName, type] of Object.entries(DETECTION_MARKERS)) {
+            try {
+                const configPath = this.resolveConfigPath(rootPath, fileName);
+                await readFileFn(configPath);
+                // 文件存在，确认检测到该类型
+                if (!detectedTypes.includes(type)) {
+                    detectedTypes.push(type);
+                }
+            }
+            catch {
+                // 文件不存在或读取失败，跳过
+            }
+        }
+        // 2. 检查根 package.json 的 workspaces 字段
+        if (rootPackageJson && rootPackageJson.workspaces) {
+            if (!detectedTypes.includes('workspaces')) {
+                detectedTypes.push('workspaces');
+            }
+        }
+        // 3. 判断结果
+        if (detectedTypes.length === 0) {
+            return ['single'];
+        }
+        // 只有一种类型时直接返回；多种类型时合并为 hybrid
+        if (detectedTypes.length === 1) {
+            return detectedTypes;
+        }
+        return ['hybrid', ...detectedTypes];
+    }
+    /**
+     * 拼接配置文件路径
+     * @param rootPath 项目根路径
+     * @param fileName 配置文件名
+     * @returns 配置文件的完整路径
+     */
+    static resolveConfigPath(rootPath, fileName) {
+        if (rootPath.startsWith('http://') || rootPath.startsWith('https://')) {
+            return `${rootPath}/${fileName}`;
+        }
+        return rootPath.endsWith(fileName) ? rootPath : `${rootPath}/${fileName}`;
+    }
+}

package/dist/factory/index.js

@@ -0,0 +1,101 @@
+import { ProjectDetector } from './detector.js';
+import { BaseStrategy } from './strategies/base.js';
+import { WorkspacesStrategy, LernaStrategy, NxStrategy, TurborepoStrategy, RushStrategy, HybridStrategy, } from './strategies/index.js';
+/**
+ * 策略注册表：将 ProjectType 映射到对应的策略构造函数
+ * 扩展新架构类型时，只需在此注册新的策略即可
+ */
+const STRATEGY_REGISTRY = {
+    workspaces: WorkspacesStrategy,
+    lerna: LernaStrategy,
+    nx: NxStrategy,
+    turborepo: TurborepoStrategy,
+    rush: RushStrategy,
+};
+/**
+ * 策略工厂
+ *
+ * 统一入口：自动检测工程类型 → 创建对应策略 → 执行扫描 → 返回标准化结果。
+ * 替代原有的 Factory 类，支持所有 Monorepo 架构类型。
+ *
+ * 用法：
+ * ```ts
+ * const result = await StrategyFactory.scan(rootPath, readFileFn, rootPackageJson);
+ * // result.detectedTypes => ['workspaces']
+ * // result.packages => [{ path, content, projectType, isRoot }, ...]
+ * ```
+ */
+export class StrategyFactory {
+    /**
+     * 执行完整的扫描流程
+     * @param rootPath 项目根路径（本地路径或远程 URL）
+     * @param readFileFn 读取文件的函数（支持本地和远程）
+     * @param rootPackageJson 根目录 package.json 的解析内容
+     * @returns 标准化扫描结果
+     */
+    static async scan(rootPath, readFileFn, rootPackageJson) {
+        // 1. 检测工程类型
+        const detectedTypes = await ProjectDetector.detect(rootPath, readFileFn, rootPackageJson);
+        // 2. 创建策略实例
+        const strategy = StrategyFactory.createStrategy(detectedTypes);
+        // 3. 执行扫描
+        const childPackages = await strategy.scan(rootPath, rootPackageJson, readFileFn);
+        // 4. 构建根 package.json 的 PackageInfo
+        const rootPackagePath = StrategyFactory.resolvePackageJsonPath(rootPath);
+        const rootPackage = {
+            path: rootPackagePath,
+            content: rootPackageJson,
+            projectType: detectedTypes[0],
+            isRoot: true,
+        };
+        return {
+            detectedTypes,
+            packages: [rootPackage, ...childPackages],
+        };
+    }
+    /**
+     * 根据检测到的工程类型创建对应的策略实例
+     * @param detectedTypes 检测到的工程类型数组
+     * @returns 策略实例
+     */
+    static createStrategy(detectedTypes) {
+        const primaryType = detectedTypes[0];
+        // 混合架构：使用 HybridStrategy（内部委托多个子策略）
+        if (primaryType === 'hybrid') {
+            return new HybridStrategy(detectedTypes);
+        }
+        // 单项目：不需要扫描子包，返回一个空扫描的策略
+        if (primaryType === 'single') {
+            class SingleStrategy extends BaseStrategy {
+                constructor() {
+                    super(...arguments);
+                    Object.defineProperty(this, "type", {
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        value: 'single'
+                    });
+                }
+                async extractPatterns() { return []; }
+            }
+            return new SingleStrategy();
+        }
+        // 查找注册表中的策略
+        const StrategyClass = STRATEGY_REGISTRY[primaryType];
+        if (!StrategyClass) {
+            throw new Error(`未注册的策略类型: ${primaryType}`);
+        }
+        return new StrategyClass();
+    }
+    /**
+     * 解析根目录 package.json 的路径
+     * @param rootPath 项目根路径
+     * @returns package.json 的完整路径
+     */
+    static resolvePackageJsonPath(rootPath) {
+        if (rootPath.endsWith('package.json')) {
+            return rootPath;
+        }
+        return `${rootPath}/package.json`;
+    }
+}

package/dist/factory/strategies/base.js

@@ -0,0 +1,95 @@
+import path from 'path';
+import { glob } from 'glob';
+/**
+ * 扫描策略抽象基类
+ *
+ * 提供通用的 glob 扫描能力，子类只需实现 extractPatterns 方法
+ * 来定义如何从配置文件中提取子包路径模式。
+ */
+export class BaseStrategy {
+    /**
+     * 执行扫描：提取路径模式 → glob 匹配 → 读取 package.json → 返回标准化结果
+     * @param rootPath 项目根路径
+     * @param rootPackageJson 根 package.json 内容
+     * @param readFileFn 读取文件函数
+     * @returns 子包 PackageInfo 数组（不包含根 package.json）
+     */
+    async scan(rootPath, rootPackageJson, readFileFn) {
+        const patterns = await this.extractPatterns(rootPath, rootPackageJson, readFileFn);
+        if (patterns.length === 0) {
+            return [];
+        }
+        // 通过 glob 匹配所有 package.json 文件路径
+        const allJsonPaths = this.matchPackageJsonFiles(rootPath, patterns);
+        // 读取每个 package.json 内容并构建标准化结果
+        const packages = [];
+        const visitedPaths = new Set();
+        for (const jsonPath of allJsonPaths) {
+            const normalizedPath = this.normalizePath(jsonPath);
+            if (visitedPaths.has(normalizedPath))
+                continue;
+            visitedPaths.add(normalizedPath);
+            try {
+                const content = await readFileFn(jsonPath);
+                packages.push({
+                    path: jsonPath,
+                    content,
+                    projectType: this.type,
+                    isRoot: false,
+                });
+            }
+            catch {
+                // 某些匹配到的文件可能读取失败（如权限问题），跳过继续
+            }
+        }
+        return packages;
+    }
+    /**
+     * 使用 glob 匹配指定路径模式下的所有 package.json 文件
+     * @param rootPath 项目根路径
+     * @param patterns 路径模式数组
+     * @returns 匹配到的 package.json 文件路径数组（已去重）
+     */
+    matchPackageJsonFiles(rootPath, patterns) {
+        const matchedFiles = [];
+        for (const pattern of patterns) {
+            const resolvedPattern = this.resolveGlobPattern(rootPath, pattern);
+            const files = glob.sync(resolvedPattern);
+            if (files.length > 0) {
+                matchedFiles.push(files);
+            }
+        }
+        return this.flatten(matchedFiles);
+    }
+    /**
+     * 解析 glob 模式：将路径模式和根路径拼接为完整的 glob 表达式
+     * @param rootPath 项目根路径
+     * @param pattern 子路径模式（如 "packages/*"）
+     * @returns 完整的 glob 模式
+     */
+    resolveGlobPattern(rootPath, pattern) {
+        // 模式本身已包含 **/package.json 格式则直接拼接
+        if (pattern.includes('package.json')) {
+            return path.resolve(rootPath, pattern);
+        }
+        // 否则默认在匹配目录下查找 **/package.json
+        return path.resolve(rootPath, pattern, '**', 'package.json');
+    }
+    /**
+     * 规范化路径：统一路径分隔符，去除尾部斜杠
+     */
+    normalizePath(filePath) {
+        return filePath.replace(/\\/g, '/').replace(/\/+$/, '');
+    }
+    /**
+     * 扁平化多维数组为一维数组
+     */
+    flatten(arr) {
+        return arr.reduce((result, element) => {
+            if (Array.isArray(element)) {
+                return result.concat(this.flatten(element));
+            }
+            return result.concat(element);
+        }, []);
+    }
+}

package/dist/factory/strategies/hybrid.strategy.js

@@ -0,0 +1,91 @@
+import { BaseStrategy } from './base.js';
+import { WorkspacesStrategy } from './workspaces.strategy.js';
+import { LernaStrategy } from './lerna.strategy.js';
+import { NxStrategy } from './nx.strategy.js';
+import { TurborepoStrategy } from './turborepo.strategy.js';
+import { RushStrategy } from './rush.strategy.js';
+/**
+ * 混合架构扫描策略
+ *
+ * 当检测到多种架构特征同时存在时（如 Workspaces + Turborepo），
+ * 合并多个策略的扫描结果并去重。
+ *
+ * 合并规则：
+ * - 同一路径的 package.json 只保留一次（按策略优先级取第一个匹配）
+ * - projectType 标记为 'hybrid'
+ */
+export class HybridStrategy extends BaseStrategy {
+    constructor(detectedTypes) {
+        super();
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'hybrid'
+        });
+        /**
+         * 混合策略中参与合并的子策略列表（按优先级排序）
+         */
+        Object.defineProperty(this, "subStrategies", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // 根据检测到的类型创建对应的子策略（排除 'hybrid' 和 'single'）
+        this.subStrategies = this.createSubStrategies(detectedTypes);
+    }
+    async extractPatterns(rootPath, rootPackageJson, readFileFn) {
+        // 合并所有子策略的路径模式并去重
+        const allPatterns = new Set();
+        for (const strategy of this.subStrategies) {
+            const patterns = await strategy.extractPatterns(rootPath, rootPackageJson, readFileFn);
+            patterns.forEach(p => allPatterns.add(p));
+        }
+        return [...allPatterns];
+    }
+    /**
+     * 执行扫描：委托给各子策略，合并结果并去重
+     */
+    async scan(rootPath, rootPackageJson, readFileFn) {
+        const allPackages = [];
+        const visitedPaths = new Set();
+        for (const strategy of this.subStrategies) {
+            const packages = await strategy.scan(rootPath, rootPackageJson, readFileFn);
+            for (const pkg of packages) {
+                const normalizedPath = this.normalizePath(pkg.path);
+                if (visitedPaths.has(normalizedPath))
+                    continue;
+                visitedPaths.add(normalizedPath);
+                // 统一标记为 hybrid 类型
+                allPackages.push({
+                    ...pkg,
+                    projectType: 'hybrid',
+                });
+            }
+        }
+        return allPackages;
+    }
+    /**
+     * 根据检测到的工程类型创建对应的子策略实例
+     */
+    createSubStrategies(detectedTypes) {
+        const strategyMap = {
+            workspaces: () => new WorkspacesStrategy(),
+            lerna: () => new LernaStrategy(),
+            nx: () => new NxStrategy(),
+            turborepo: () => new TurborepoStrategy(),
+            rush: () => new RushStrategy(),
+        };
+        const strategies = [];
+        for (const type of detectedTypes) {
+            if (type === 'hybrid' || type === 'single')
+                continue;
+            const factory = strategyMap[type];
+            if (factory) {
+                strategies.push(factory());
+            }
+        }
+        return strategies;
+    }
+}

package/dist/factory/strategies/index.js

@@ -0,0 +1,7 @@
+export { BaseStrategy } from './base.js';
+export { WorkspacesStrategy } from './workspaces.strategy.js';
+export { LernaStrategy } from './lerna.strategy.js';
+export { NxStrategy } from './nx.strategy.js';
+export { TurborepoStrategy } from './turborepo.strategy.js';
+export { RushStrategy } from './rush.strategy.js';
+export { HybridStrategy } from './hybrid.strategy.js';

package/dist/factory/strategies/lerna.strategy.js

@@ -0,0 +1,48 @@
+import { BaseStrategy } from './base.js';
+/**
+ * Lerna 扫描策略
+ *
+ * 从 lerna.json 中提取子包路径：
+ * - 当 useWorkspaces: true 时，复用 workspaces 字段（避免重复扫描）
+ * - 否则从 lerna.json 的 packages 字段提取路径
+ */
+export class LernaStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'lerna'
+        });
+    }
+    async extractPatterns(rootPath, rootPackageJson, readFileFn) {
+        const lernaPath = `${rootPath}/lerna.json`;
+        let lernaConfig;
+        try {
+            lernaConfig = await readFileFn(lernaPath);
+        }
+        catch {
+            return [];
+        }
+        // useWorkspaces: true 时，复用根 package.json 的 workspaces 字段
+        if (lernaConfig?.useWorkspaces && rootPackageJson?.workspaces) {
+            if (Array.isArray(rootPackageJson.workspaces)) {
+                return rootPackageJson.workspaces.filter((w) => typeof w === 'string');
+            }
+            // 对象格式的 workspaces：合并所有值
+            const result = [];
+            for (const value of Object.values(rootPackageJson.workspaces)) {
+                if (Array.isArray(value)) {
+                    result.push(...value.filter((v) => typeof v === 'string'));
+                }
+            }
+            return result;
+        }
+        // 否则从 lerna.json 的 packages 字段提取
+        if (lernaConfig?.packages && Array.isArray(lernaConfig.packages)) {
+            return lernaConfig.packages.filter((p) => typeof p === 'string');
+        }
+        return [];
+    }
+}

package/dist/factory/strategies/nx.strategy.js

@@ -0,0 +1,47 @@
+import { BaseStrategy } from './base.js';
+/**
+ * Nx 扫描策略
+ *
+ * Nx 不一定配置 workspaces 字段，子包路径通过以下方式确定：
+ * 1. 读取 nx.json，检查 implicitDependencies 或 workspaceLayout
+ * 2. 默认遍历 apps/、libs/、packages/ 目录下所有包含 package.json 的子目录
+ */
+export class NxStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'nx'
+        });
+    }
+    async extractPatterns(rootPath, rootPackageJson, readFileFn) {
+        const patterns = [];
+        // 优先从 package.json 的 workspaces 字段提取（Nx 项目可能同时配置 workspaces）
+        if (rootPackageJson?.workspaces) {
+            if (Array.isArray(rootPackageJson.workspaces)) {
+                patterns.push(...rootPackageJson.workspaces.filter((w) => typeof w === 'string'));
+            }
+        }
+        // 如果 workspaces 已提供路径，直接使用
+        if (patterns.length > 0) {
+            return patterns;
+        }
+        // 尝试从 nx.json 中读取 workspaceLayout 配置
+        try {
+            const nxConfig = await readFileFn(`${rootPath}/nx.json`);
+            if (nxConfig?.workspaceLayout) {
+                const { appsDir = 'apps', libsDir = 'libs' } = nxConfig.workspaceLayout;
+                patterns.push(`${appsDir}/*`, `${libsDir}/*`);
+                return patterns;
+            }
+        }
+        catch {
+            // nx.json 读取失败，使用默认目录
+        }
+        // Nx 默认目录
+        patterns.push('apps/*', 'libs/*');
+        return patterns;
+    }
+}

package/dist/factory/strategies/rush.strategy.js

@@ -0,0 +1,67 @@
+import { BaseStrategy } from './base.js';
+/**
+ * Rush 扫描策略
+ *
+ * 从 rush.json 的 projects 数组中提取每个子包的 projectFolder 路径。
+ * Rush 的路径格式为直接目录路径（不带 glob 通配符），如 "apps/app-a"。
+ */
+export class RushStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'rush'
+        });
+    }
+    async extractPatterns(rootPath, _rootPackageJson, readFileFn) {
+        let rushConfig;
+        try {
+            rushConfig = await readFileFn(`${rootPath}/rush.json`);
+        }
+        catch {
+            return [];
+        }
+        if (!rushConfig?.projects || !Array.isArray(rushConfig.projects)) {
+            return [];
+        }
+        // 从每个 project 中提取 projectFolder 作为直接路径
+        // Rush 的 projectFolder 是精确目录路径，不使用 glob 通配符
+        return rushConfig.projects
+            .map((project) => project.projectFolder)
+            .filter((folder) => typeof folder === 'string' && folder.length > 0);
+    }
+    /**
+     * Rush 的路径是精确目录，重写 scan 方法直接读取 package.json
+     */
+    async scan(rootPath, rootPackageJson, readFileFn) {
+        const patterns = await this.extractPatterns(rootPath, rootPackageJson, readFileFn);
+        if (patterns.length === 0) {
+            return [];
+        }
+        const packages = [];
+        const visitedPaths = new Set();
+        for (const folder of patterns) {
+            // Rush 路径直接指向包含 package.json 的目录
+            const jsonPath = `${rootPath}/${folder}/package.json`;
+            const normalizedPath = this.normalizePath(jsonPath);
+            if (visitedPaths.has(normalizedPath))
+                continue;
+            visitedPaths.add(normalizedPath);
+            try {
+                const content = await readFileFn(jsonPath);
+                packages.push({
+                    path: jsonPath,
+                    content,
+                    projectType: this.type,
+                    isRoot: false,
+                });
+            }
+            catch {
+                // 跳过读取失败的文件
+            }
+        }
+        return packages;
+    }
+}

package/dist/factory/strategies/turborepo.strategy.js

@@ -0,0 +1,49 @@
+import { BaseStrategy } from './base.js';
+/**
+ * Turborepo 扫描策略
+ *
+ * turbo.json 本身不定义子包路径，仅定义构建管道。
+ * 因此 Turborepo 策略复用 workspaces 的路径配置：
+ * - package.json 的 workspaces 字段
+ * - pnpm-workspace.yaml 的 packages 字段
+ */
+export class TurborepoStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'turborepo'
+        });
+    }
+    async extractPatterns(rootPath, rootPackageJson, readFileFn) {
+        const patterns = [];
+        // 从 package.json 的 workspaces 字段提取
+        if (rootPackageJson?.workspaces) {
+            if (Array.isArray(rootPackageJson.workspaces)) {
+                patterns.push(...rootPackageJson.workspaces.filter((w) => typeof w === 'string'));
+            }
+            else if (typeof rootPackageJson.workspaces === 'object') {
+                for (const value of Object.values(rootPackageJson.workspaces)) {
+                    if (Array.isArray(value)) {
+                        patterns.push(...value.filter((v) => typeof v === 'string'));
+                    }
+                }
+            }
+        }
+        // 尝试从 pnpm-workspace.yaml 补充
+        if (patterns.length === 0) {
+            try {
+                const yamlContent = await readFileFn(`${rootPath}/pnpm-workspace.yaml`);
+                if (yamlContent?.packages && Array.isArray(yamlContent.packages)) {
+                    patterns.push(...yamlContent.packages);
+                }
+            }
+            catch {
+                // 跳过
+            }
+        }
+        return patterns;
+    }
+}

package/dist/factory/strategies/workspaces.strategy.js

@@ -0,0 +1,61 @@
+import { BaseStrategy } from './base.js';
+/**
+ * Workspaces 扫描策略
+ *
+ * 从 package.json 的 workspaces 字段或 pnpm-workspace.yaml 中提取子包路径。
+ * workspaces 字段支持字符串数组和对象数组两种格式：
+ * - 字符串: ["packages/*", "apps/*"]
+ * - 对象:   [{ "packages": ["core/*", "ui/*"] }]
+ */
+export class WorkspacesStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'workspaces'
+        });
+    }
+    async extractPatterns(rootPath, rootPackageJson, readFileFn) {
+        const patterns = [];
+        // 优先从 package.json 的 workspaces 字段提取
+        if (rootPackageJson?.workspaces) {
+            patterns.push(...this.parseWorkspacesField(rootPackageJson.workspaces));
+        }
+        // 尝试从 pnpm-workspace.yaml 补充（package.json 中未配置时）
+        if (patterns.length === 0) {
+            try {
+                const yamlPath = `${rootPath}/pnpm-workspace.yaml`;
+                const yamlContent = await readFileFn(yamlPath);
+                if (yamlContent?.packages && Array.isArray(yamlContent.packages)) {
+                    patterns.push(...yamlContent.packages);
+                }
+            }
+            catch {
+                // pnpm-workspace.yaml 不存在或非 YAML 格式，跳过
+            }
+        }
+        return patterns;
+    }
+    /**
+     * 解析 workspaces 字段，兼容数组和对象两种格式
+     */
+    parseWorkspacesField(workspaces) {
+        if (Array.isArray(workspaces)) {
+            // 字符串数组: ["packages/*", "apps/*"]
+            return workspaces.filter((w) => typeof w === 'string');
+        }
+        if (typeof workspaces === 'object' && workspaces !== null) {
+            // 对象格式: { "packages": ["core/*", "ui/*"] }
+            const result = [];
+            for (const value of Object.values(workspaces)) {
+                if (Array.isArray(value)) {
+                    result.push(...value.filter((v) => typeof v === 'string'));
+                }
+            }
+            return result;
+        }
+        return [];
+    }
+}

package/dist/factory/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/server.js

@@ -1,8 +1,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import { createPageJson, getPageJson } from '../package-json/index.js';
+import { createPageJson, getPageJsonWithPaths } from '../package-json/index.js';
 import { createWorkDir, deleteWorkDir } from '../file/index.js';
-import { audit } from '../audit/index.js';
+import { Audit } from '../audit/index.js';
+import { generateSummaryReport } from '../report-generator/index.js';
 import path from 'path';
 import fs from 'fs';
 export function createAuditServer() {
@@ -16,29 +17,45 @@ export function createAuditServer() {
     }, async ({ project_url }) => {
         let workDir = null;
         try {
-            // 判断 project_url 是本地路径还是远程 URL
-            const isLocal = fs.existsSync(project_url);
-            let targetDir;
-            if (isLocal) {
-                // 本地路径：report 写入目标项目根目录
-                targetDir = path.resolve(project_url);
+            const workDir = await createWorkDir(); // 创建临时目录
+            // 获取本地或者远程工程文件的package.json（标准化扫描结果）
+            const scanResult = await getPageJsonWithPaths(project_url);
+            const { packages: packagesInfo, detectedTypes } = scanResult;
+            console.log(`\n📁 检测到工程类型: ${detectedTypes.join(', ')}`);
+            console.log(`📦 发现 ${packagesInfo.length} 个 package.json`);
+            // 在工作目录生成临时的 package.json
+            const packages = packagesInfo.map((pkg) => pkg.content);
+            await createPageJson(workDir, packages);
+            // 获取 workDir 下的所有子目录（每个子目录对应一个 package）
+            const subDirs = fs.readdirSync(workDir).filter(item => {
+                const itemPath = path.join(workDir, item);
+                return fs.statSync(itemPath).isDirectory();
+            });
+            // 对每个子目录进行安全审计，并收集审计结果
+            const auditResults = [];
+            for (let i = 0; i < subDirs.length; i++) {
+                const subDir = subDirs[i];
+                const subDirPath = path.join(workDir, subDir);
+                console.log(`\n🔍 开始审计: ${subDir}`);
+                // 创建 Audit 实例并获取审计结果（不生成单独文件）
+                const auditInstance = new Audit(subDirPath, '');
+                const auditResult = JSON.parse(await auditInstance.command());
+                // 获取对应的 package.json 路径和工程类型
+                const packageJsonPath = packagesInfo[i]?.path || '';
+                const projectType = packagesInfo[i]?.projectType || 'unknown';
+                auditResults.push({
+                    subDir,
+                    packageJsonPath,
+                    projectType,
+                    auditResult
+                });
             }
-            else {
-                // 远程 URL：report 写入 MCP 客户端工作目录（调用方项目）
-                targetDir = process.cwd();
-            }
-            // 1. 创建临时工作目录
-            workDir = await createWorkDir();
-            // 2. 获取目标项目的 package.json
-            const pkgJson = await getPageJson(project_url);
-            // 3. 在临时目录写入 package.json，优先复制源项目 lock 文件
-            const sourcePath = isLocal ? path.resolve(project_url) : undefined;
-            await createPageJson(workDir, pkgJson, sourcePath);
-            // 4. 执行 npm audit 并生成 Markdown 报告到目标目录
-            const reportPath = path.join(targetDir, 'audit.md');
-            const report = await audit(workDir, reportPath);
+            // 生成汇总报告到项目根目录
+            console.log(`\n📊 生成汇总报告...`);
+            const summaryPath = path.join(process.cwd(), 'audit-summary.md');
+            await generateSummaryReport(auditResults, summaryPath);
             return {
-                content: [{ type: 'text', text: report }],
+                content: [{ type: 'text', text: `审计报告已生成: ${summaryPath}` }],
             };
         }
         catch (error) {
@@ -48,7 +65,7 @@ export function createAuditServer() {
             };
         }
         finally {
-            // 5. 无论成功失败，清理临时目录
+            // 7. 无论成功失败，清理临时目录
             if (workDir) {
                 try {
                     await deleteWorkDir(workDir);

package/dist/package-json/index.js

@@ -1,68 +1,98 @@
 import path from 'path';
 import fs from 'fs';
 import { runCommand } from '../common/utils.js';
+import { StrategyFactory } from '@/factory/index.js';
 /**
- * 获取package.json 文件内容
+ * 获取 package.json 文件内容（标准化结构，含路径和工程类型信息）
  * @param url 判断当前项目的路径是远程还是本地
- * @returns 返回获取到的package.json 文件内容
+ * @returns 标准化扫描结果
  */
-export async function getPageJson(url) {
+export async function getPageJsonWithPaths(url) {
     if (url.startsWith('http://') || url.startsWith('https://')) {
-        // 处理远程URL
-        return getRemotePageJson(url);
+        return getRemotePageJsonWithPaths(url);
     }
     else {
-        // 处理本地路径
-        return getLocalPageJson(url);
+        return getLocalPageJsonWithPaths(url);
     }
 }
 /**
- * 获取本地package.json 文件内容
+ * 获取本地 package.json（标准化结构）
  * @param projectPath 本地路径
- * @returns 返回获取到的package.json 文件内容
+ * @returns 标准化扫描结果
  */
-async function getLocalPageJson(projectPath) {
-    const packageJsonPath = path.join(projectPath, 'package.json');
-    const packageJson = await fs.promises.readFile(packageJsonPath, 'utf8');
-    return JSON.parse(packageJson);
+async function getLocalPageJsonWithPaths(projectPath) {
+    // 定义本地读取文件的函数
+    const readFileFn = async (filePath) => {
+        let packageJsonPath = filePath;
+        if (!filePath.includes('package.json')) {
+            packageJsonPath = path.join(filePath, 'package.json');
+        }
+        const packageJson = await fs.promises.readFile(packageJsonPath, 'utf8');
+        return JSON.parse(packageJson);
+    };
+    // 读取根目录的 package.json
+    const rootJson = await readFileFn(projectPath);
+    // 使用 StrategyFactory 自动检测架构类型并扫描所有子包
+    return StrategyFactory.scan(projectPath, readFileFn, rootJson);
 }
 /**
- * 获取远程package.json 文件内容 比如gitHub
+ * 获取远程 package.json（标准化结构）
  * @param url 远程URL
- * @returns 返回获取到的package.json 文件内容
- * https://github.com/djdjjsfsks/manage/blob/main
+ * @returns 标准化扫描结果
  */
-async function getRemotePageJson(url) {
-    const response = await fetch(`${url}/package.json`);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch package.json from ${url}`);
-    }
-    const packageJson = await response.text();
-    return JSON.parse(packageJson);
+async function getRemotePageJsonWithPaths(url) {
+    // 定义远程读取文件的函数
+    const readFileFn = async (filePath) => {
+        const response = await fetch(filePath);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${filePath}`);
+        }
+        const packageJson = await response.text();
+        return JSON.parse(packageJson);
+    };
+    // 读取根目录的 package.json
+    const rootJson = await readFileFn(`${url}/package.json`);
+    // 使用 StrategyFactory 自动检测架构类型并扫描所有子包
+    return StrategyFactory.scan(url, readFileFn, rootJson);
 }
 /**
- * 创建package.json 文件，优先复制源项目的 package-lock.json，
- * 仅在无 lock 文件时才执行 npm install 生成
+ * 创建 package.json 文件，为每个包生成独立的 package.json 和 lock 文件
  * @param workDir 工作目录路径
- * @param val 页面配置对象
- * @param sourcePath 源项目路径（用于查找已有的 lock 文件）
+ * @param val 页面配置对象或对象数组（支持 Monorepo 多个 package.json）
  */
-export async function createPageJson(workDir, val, sourcePath) {
-    const packageJsonPath = path.join(workDir, 'package.json');
-    await fs.promises.writeFile(packageJsonPath, JSON.stringify(val, null, 2));
-    const lockFileName = 'package-lock.json';
-    const sourceLockPath = sourcePath ? path.join(sourcePath, lockFileName) : null;
-    const workLockPath = path.join(workDir, lockFileName);
-    // 优先复制源项目已有的 lock 文件，跳过耗时的 npm install
-    if (sourceLockPath && fs.existsSync(sourceLockPath)) {
-        await fs.promises.copyFile(sourceLockPath, workLockPath);
-        process.stderr.write(`[mcp] 已复制 ${lockFileName}，跳过 npm install\n`);
-    }
-    else {
-        // 无 lock 文件时才生成，添加优化标志加速
+export async function createPageJson(workDir, val) {
+    // 处理数组或单个对象
+    const packages = Array.isArray(val) ? val : [val];
+    // 记录已使用的目录名，避免重复
+    const usedNames = new Map();
+    for (let i = 0; i < packages.length; i++) {
+        const pkg = packages[i];
+        // 获取包名作为子目录名
+        const pkgName = pkg.name || 'package';
+        // 清理包名中的特殊字符，用作目录名
+        let safeName = pkgName.replace(/^@/, '').replace(/\//g, '--');
+        // 如果目录名已存在，添加索引
+        if (usedNames.has(safeName)) {
+            usedNames.set(safeName, usedNames.get(safeName) + 1);
+            safeName = `${safeName}-${usedNames.get(safeName)}`;
+        }
+        else {
+            usedNames.set(safeName, 0);
+        }
+        const pkgDir = path.join(workDir, safeName);
+        // 创建子目录
+        await fs.promises.mkdir(pkgDir, { recursive: true });
+        // 移除 workspaces 字段，避免子包被误认为是 workspace 根目录
+        const { workspaces, ...pkgWithoutWorkspaces } = pkg;
+        // 写入 package.json
+        const packageJsonPath = path.join(pkgDir, 'package.json');
+        await fs.promises.writeFile(packageJsonPath, JSON.stringify(pkgWithoutWorkspaces, null, 2));
+        // 直接执行 npm install 生成干净的 lock 文件
+        // 使用 --no-workspaces 防止 npm 识别父目录的 workspace 配置
         await runCommand('npm', [
             'install', '--package-lock-only', '--force',
             '--ignore-scripts', '--no-audit', '--no-fund',
-        ], { path: workDir });
+            '--no-workspaces'
+        ], { path: pkgDir });
     }
 }

package/dist/report-generator/index.js

@@ -0,0 +1,119 @@
+import fs from 'fs';
+/**
+ * 生成汇总报告（格式与单个项目 audit.md 一致）
+ * @param auditResults 审计结果数组
+ * @param outputPath 输出路径
+ * @param isMcpMode 是否为 MCP 模式（MCP 模式不写入文件，直接返回内容）
+ */
+export async function generateSummaryReport(auditResults, outputPath, isMcpMode = false) {
+    let markdown = `# Monorepo 安全审计汇总报告\n\n`;
+    markdown += `**生成时间:** ${new Date().toLocaleString()}\n\n`;
+    for (const result of auditResults) {
+        const { packageJsonPath, auditResult } = result;
+        // 使用 package.json 路径作为标题
+        markdown += `# ${packageJsonPath} 项目安全审计报告\n\n`;
+        markdown += `**生成时间:** ${new Date().toLocaleString()}\n`;
+        markdown += `**审计路径:** ${process.cwd()}\n\n`;
+        // 漏洞统计 — 兼容 npm audit JSON 格式
+        const vulnerabilities = auditResult.vulnerabilities || {};
+        const metadata = auditResult.metadata || {};
+        const stats = metadata.vulnerabilities || {};
+        // 处理无漏洞场景
+        const vulnCount = Object.keys(vulnerabilities).length;
+        if (vulnCount === 0 && (!stats.total || stats.total === 0)) {
+            markdown += `## 审计结果\n\n`;
+            markdown += `**未发现安全漏洞。** 所有依赖均通过安全审计。\n\n`;
+        }
+        else {
+            markdown += `## 漏洞统计\n\n`;
+            markdown += `| 严重程度 | 数量 |\n`;
+            markdown += `|----------|------|\n`;
+            markdown += `| **严重** | ${stats.critical || 0} |\n`;
+            markdown += `| **高危** | ${stats.high || 0} |\n`;
+            markdown += `| **中危** | ${stats.moderate || 0} |\n`;
+            markdown += `| **低危** | ${stats.low || 0} |\n`;
+            markdown += `| **信息** | ${stats.info || 0} |\n`;
+            markdown += `| **总计** | ${stats.total || vulnCount} |\n\n`;
+            // 按严重程度分组漏洞
+            const vulnerabilitiesBySeverity = {};
+            Object.entries(vulnerabilities).forEach(([key, vuln]) => {
+                const severity = vuln.severity || 'unknown';
+                if (!vulnerabilitiesBySeverity[severity]) {
+                    vulnerabilitiesBySeverity[severity] = [];
+                }
+                vulnerabilitiesBySeverity[severity].push({
+                    key,
+                    ...vuln
+                });
+            });
+            // 严重程度排序（从高到低）
+            const severityOrder = ['critical', 'high', 'moderate', 'low', 'info', 'unknown'];
+            severityOrder.forEach(severity => {
+                const vulnList = vulnerabilitiesBySeverity[severity];
+                if (vulnList && vulnList.length > 0) {
+                    const severityZh = {
+                        'critical': '严重',
+                        'high': '高危',
+                        'moderate': '中危',
+                        'low': '低危',
+                        'info': '信息',
+                        'unknown': '未知'
+                    }[severity] || severity;
+                    markdown += `## ${severityZh} 漏洞\n\n`;
+                    vulnList.forEach((vuln, index) => {
+                        markdown += `### ${index + 1}. ${vuln.name} (${vuln.key})\n\n`;
+                        markdown += `**漏洞编号:** ${vuln.via?.[0]?.url || vuln.via?.[0]?.id || vuln.via?.[0]?.title || 'N/A'}\n\n`;
+                        if (vuln.cvss?.score) {
+                            markdown += `**CVSS 分数:** ${vuln.cvss.score}\n`;
+                            markdown += `**CVSS 等级:** ${vuln.cvss.severity}\n\n`;
+                        }
+                        markdown += `**漏洞等级:** ${vuln.severity}\n`;
+                        markdown += `**依赖路径:** \`${vuln.effects?.join(' → ') || vuln.key}\`\n`;
+                        markdown += `**受影响的版本:** ${vuln.range}\n`;
+                        markdown += `**修复版本:** ${vuln.fixAvailable?.name ? `${vuln.fixAvailable.name}@${vuln.fixAvailable.version}` : '暂无修复'}\n\n`;
+                        markdown += `**依赖关系:**\n`;
+                        if (vuln.nodes && vuln.nodes.length > 0) {
+                            vuln.nodes.forEach((node) => {
+                                markdown += `- ${node}\n`;
+                            });
+                        }
+                        else {
+                            markdown += `- 直接依赖\n`;
+                        }
+                        markdown += `\n`;
+                        if (vuln.range === '*' || vuln.range === '>=0.0.0') {
+                            markdown += `⚠️ **警告:** 此依赖影响所有版本\n\n`;
+                        }
+                    });
+                }
+            });
+        }
+        // 修复建议
+        markdown += `## 修复建议\n\n`;
+        if (auditResult.actions && auditResult.actions.length > 0) {
+            auditResult.actions.forEach((action, index) => {
+                markdown += `${index + 1}. **${action.action}**\n`;
+                if (action.resolves && action.resolves.length > 0) {
+                    action.resolves.forEach((resolve) => {
+                        markdown += `   - 修复 \`${resolve.id}\`: ${resolve.path}\n`;
+                    });
+                }
+                markdown += `\n`;
+            });
+        }
+        else {
+            markdown += `1. 运行 \`npm audit fix\` 自动修复可修复的漏洞\n`;
+            markdown += `2. 运行 \`npm audit fix --force\` 强制修复所有漏洞（可能有破坏性变更）\n`;
+            markdown += `3. 手动更新受影响包的版本\n\n`;
+        }
+        markdown += `\n---\n\n`; // 分隔符
+    }
+    // MCP 模式直接返回内容，不写入文件
+    if (isMcpMode) {
+        return markdown;
+    }
+    // CLI 模式写入文件
+    await fs.promises.writeFile(outputPath, markdown, 'utf-8');
+    console.log(`✅ 汇总报告已生成: ${outputPath}`);
+    return markdown;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chen_258/audit-tool",
-  "version": "1.0.5",
+  "version": "1.1.1",
   "type": "module",
   "main": "./dist/mcp/index.js",
   "bin": {
@@ -8,12 +8,21 @@
   },
   "files": [
     "dist/"
-  ],  
+  ],
   "engines": {
     "node": "16.0.0"
   },
+  "workspaces": [
+    "src/common",
+    "src/audit"
+  ],
   "description": "基于 npm audit 的 MCP 安全审计服务器",
-  "keywords": ["mcp", "npm-audit", "security", "vulnerability"],
+  "keywords": [
+    "mcp",
+    "npm-audit",
+    "security",
+    "vulnerability"
+  ],
   "license": "MIT",
   "scripts": {
     "dev": "vite",
@@ -28,6 +37,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
+    "glob": "^13.0.6",
     "zod": "^4.3.6"
   },
   "devDependencies": {