js-code-detector 0.0.43 → 0.0.47

package/dist/cjs/util/report_util/generateGitDiffReport.d.ts

@@ -4,14 +4,19 @@ export declare function generateGitDiffReport(arg: {
     madgeResult: IMadgeInstance;
     parsedAlias: Record<string, any>;
     targetDirPath: string;
-    generateFile?: ('dependence_map.json' | 'partial_dependence_map.json' | 'report.json' | typeof reportFileName)[];
+    generateFile?: ('dependence_map.json' | 'partial_dependence_map.json' | 'report.json' | 'gitDiffDetail.json' | typeof reportFileName)[];
 }): Promise<{
-    mdContent: string;
-    dependenceJson: Record<string, any>;
-    upstreamDependenceJson: Record<string, any>;
+    dependenceJson: {
+        import2export: Record<string, string>;
+        export2export: Record<string, string>;
+        mapFilePathToExportAllSources: Record<string, string[]>;
+        indirectExportMembers: Record<string, string>;
+    };
     partialDependenceJson: Record<string, any>;
     reports: {
         dangerIdentifiers: string[];
+        topEffectedExportsAdded: string[];
+        topEffectedExportsRemoved: string[];
         blockReports: {
             diff_txt: string[];
             infos: {

package/dist/cjs/util/report_util/generateGitDiffReport.js

@@ -38,42 +38,47 @@ var import__ = require("../../index");
 var import_format_git_diff_content = require("../format_git_diff_content");
 var import_utils = require("@umijs/utils");
 var import_report_util = require("../report_util");
-var import_createMdByJson = require("./createMdByJson");
 var import_createDependenceMap = require("./createDependenceMap");
 var import_dayjs = __toESM(require("dayjs"));
+var import_collectUpstreamFiles = __toESM(require("../shared/collectUpstreamFiles"));
+var import_filterEffectedCode = __toESM(require("./filterEffectedCode"));
 var reportFileName = "git_diff_report.md";
 async function generateGitDiffReport(arg) {
-  const { madgeResult, parsedAlias, targetDirPath, generateFile = ["upstream_dependence_map.json", "dependence_map.json", "partial_dependence_map.json", "report.json", reportFileName] } = arg;
+  const { madgeResult, parsedAlias, targetDirPath, generateFile = ["upstream_dependence_map.json", "dependence_map.json", "partial_dependence_map.json", "report.json", "gitDiffDetail.json", reportFileName] } = arg;
+  const absPathPrefix = targetDirPath + "/";
   const { tree } = madgeResult;
+  const projectFilePaths = Object.keys(tree);
+  import_utils.logger.info("读取 git diff 内容，生成 json 文件");
   const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(targetDirPath, import__.gitDiffFileName), "utf-8");
   const gitDiffDetail = (0, import_format_git_diff_content.formatGitDiffContent)(diff_txt);
-  const absPathPrefix = targetDirPath + "/";
-  const usingFileNoPrefix = Object.keys(tree);
-  const usingFilePaths = usingFileNoPrefix.map((item) => (0, import_utils.winPath)((0, import_path.join)(absPathPrefix, item)));
-  const groupGitDiffLines = gitDiffDetail.filter((item) => usingFileNoPrefix.includes(item.filePath));
-  const changedFilePaths = groupGitDiffLines.map((item) => item.filePath);
+  const modifiedFilePaths = gitDiffDetail.map((item) => item.filePath);
+  const upstreamFilePaths = (0, import_collectUpstreamFiles.default)(madgeResult, modifiedFilePaths);
+  const upstreamFileFullPaths = upstreamFilePaths.map((item) => (0, import_utils.winPath)((0, import_path.join)(absPathPrefix, item)));
+  const groupGitDiffLines = gitDiffDetail.filter((item) => upstreamFilePaths.includes(item.filePath));
   const time = (0, import_dayjs.default)().format("YYYYMDD_HHmm");
-  let dependenceJson = {};
+  let dependenceJson = {
+    indirectExportMembers: {},
+    import2export: {},
+    export2export: {},
+    mapFilePathToExportAllSources: {}
+  };
   let partialDependenceJson = {};
-  let upstreamDependenceJson = {};
+  let reports = [];
   try {
-    dependenceJson = (0, import_createDependenceMap.createDependenceMap)(usingFilePaths, parsedAlias, absPathPrefix);
-    partialDependenceJson = Object.fromEntries(changedFilePaths.map((p) => [p, dependenceJson[p]]));
-    upstreamDependenceJson = Object.fromEntries(changedFilePaths.map((p) => [p, madgeResult.depends(p)]));
+    import_utils.logger.info("生成 dependenceJson ...");
+    dependenceJson = (0, import_createDependenceMap.createExportedNameToReferenceLocalSet)(upstreamFileFullPaths, parsedAlias, absPathPrefix, projectFilePaths);
+    reports = (0, import_report_util.createDetectReport)({ groupGitDiffLines, tree, absPathPrefix });
+    partialDependenceJson = (0, import_filterEffectedCode.default)(reports, dependenceJson);
   } catch (e) {
-    console.warn("dependenceJson 生成失败", e);
+    import_utils.logger.warn("dependenceJson 生成失败", e);
   }
-  const reports = (0, import_report_util.createDetectReport)({ groupGitDiffLines, tree, absPathPrefix });
-  const mdContent = (0, import_createMdByJson.createMdByJson)(reports);
-  generateFile.includes("upstream_dependence_map.json") && (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_upstream_dependence_map.json`), JSON.stringify(dependenceJson, null, 2), { encoding: "utf-8", flag: "w" });
+  import_utils.logger.info("完成");
   generateFile.includes("dependence_map.json") && (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_dependence_map.json`), JSON.stringify(dependenceJson, null, 2), { encoding: "utf-8", flag: "w" });
   generateFile.includes("partial_dependence_map.json") && (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_partial_dependence_map.json`), JSON.stringify(partialDependenceJson, null, 2), { encoding: "utf-8", flag: "w" });
   generateFile.includes("report.json") && (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_report.json`), JSON.stringify(reports, null, 2), { encoding: "utf-8", flag: "w" });
-  generateFile.includes(reportFileName) && (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_${reportFileName}`), mdContent, { encoding: "utf-8", flag: "w" });
+  generateFile.includes("gitDiffDetail.json") && (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_gitDiffDetail.json`), JSON.stringify(gitDiffDetail, null, 2), { encoding: "utf-8", flag: "w" });
   return {
-    mdContent,
     dependenceJson,
-    upstreamDependenceJson,
     partialDependenceJson,
     reports
   };

package/dist/cjs/util/report_util.d.ts

@@ -26,6 +26,8 @@ type Arg = {
 };
 export declare function createDetectReport(arg: Arg): {
     dangerIdentifiers: string[];
+    topEffectedExportsAdded: string[];
+    topEffectedExportsRemoved: string[];
     blockReports: {
         diff_txt: string[];
         infos: {
@@ -35,7 +37,7 @@ export declare function createDetectReport(arg: Arg): {
             effectsDownstream: string[];
         }[];
     }[];
-    type: "add" | "delete" | "modify";
+    type: "delete" | "modify" | "add";
     filesDependsOnMe: string[];
     undefinedIdentifiers: string[];
     filePath: string;

package/dist/cjs/util/report_util.js

@@ -63,6 +63,14 @@ function createDetectReport(arg) {
   });
   return reports.map((reportItem) => {
     const { _fileAddedNodesPaths, _fileRemovedNodesPaths, filePath, blockReports, ...reportProperties } = reportItem;
+    const topEffectedExportsAdded = _fileAddedNodesPaths.map((e) => {
+      const { node } = e;
+      return import_AstUtil.default.findExportedMembersNameFromAncestors(node);
+    }).flat();
+    const topEffectedExportsRemoved = _fileRemovedNodesPaths.map((e) => {
+      const { node } = e;
+      return import_AstUtil.default.findExportedMembersNameFromAncestors(node);
+    }).flat();
     (0, import_diffBlockDetect.reportItemDetect)(reportItem, absPathPrefix);
     const fileAddedNodesPaths = reportItem._fileAddedNodesPaths.map((item) => item.nodePath);
     const fileRemovedNodesPaths = reportItem._fileRemovedNodesPaths.map((item) => import_AstUtil.default.getShortNodeMsg(item.node, true));
@@ -70,6 +78,8 @@ function createDetectReport(arg) {
       filePath,
       ...reportProperties,
       dangerIdentifiers: fileRemovedNodesPaths,
+      topEffectedExportsAdded: [...new Set(topEffectedExportsAdded)],
+      topEffectedExportsRemoved: [...new Set(topEffectedExportsRemoved)],
       blockReports: blockReports.map((blockReport) => {
         const { diff_txt } = blockReport;
         const addNodeAndPaths = blockReport.addNodeAndPaths.filter((e) => fileAddedNodesPaths.includes(e.nodePath));

package/dist/cjs/util/shared/collectUpstreamFiles.d.ts

@@ -0,0 +1,2 @@
+import { IMadgeInstance } from "../report_util/getMadgeInstance";
+export default function collectUpstreamFiles(madgeResult: IMadgeInstance, modifiedFilePaths: string[], maxCount?: number): string[];

package/dist/cjs/util/shared/collectUpstreamFiles.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/shared/collectUpstreamFiles.ts
+var collectUpstreamFiles_exports = {};
+__export(collectUpstreamFiles_exports, {
+  default: () => collectUpstreamFiles
+});
+module.exports = __toCommonJS(collectUpstreamFiles_exports);
+function collectUpstreamFiles(madgeResult, modifiedFilePaths, maxCount = 30) {
+  const changedFilePaths = [...modifiedFilePaths];
+  let tmpFiles = [...modifiedFilePaths];
+  for (let i = 0; i < 3; i++) {
+    tmpFiles = tmpFiles.map((file) => madgeResult.depends(file)).flat();
+    if (tmpFiles.length === 0) {
+      break;
+    }
+    changedFilePaths.push(...tmpFiles);
+    if (changedFilePaths.length > maxCount) {
+      break;
+    }
+  }
+  return [...new Set(changedFilePaths)];
+}

package/dist/cjs/util/shared/getRepoSupportFlag.d.ts

@@ -1,3 +1,4 @@
 import { semver } from "@umijs/utils";
-export declare function getRepoType(jsonPath: string): "umi" | null | undefined;
+export declare function isRepoTypeSupported(repoType: string): boolean;
+export declare function getRepoType(jsonPath: string): "unknown" | "umi" | "vue2";
 export declare function getMinVersion(jsonPath: string, depName: string): semver.SemVer | null | undefined;

package/dist/cjs/util/shared/getRepoSupportFlag.js

@@ -20,27 +20,35 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var getRepoSupportFlag_exports = {};
 __export(getRepoSupportFlag_exports, {
   getMinVersion: () => getMinVersion,
-  getRepoType: () => getRepoType
+  getRepoType: () => getRepoType,
+  isRepoTypeSupported: () => isRepoTypeSupported
 });
 module.exports = __toCommonJS(getRepoSupportFlag_exports);
 var import_fs = require("fs");
 var import_utils = require("@umijs/utils");
+function isRepoTypeSupported(repoType) {
+  return ["umi"].includes(repoType);
+}
 function getRepoType(jsonPath) {
-  var _a;
+  var _a, _b, _c;
   const isExist = (0, import_fs.existsSync)(jsonPath);
   if (!isExist)
-    return null;
+    return "unknown";
   const packageJson = (0, import_fs.readFileSync)(jsonPath, "utf-8");
   if (!packageJson)
-    return null;
+    return "unknown";
   try {
     const packageJsonObj = JSON.parse(packageJson);
     if ((_a = packageJsonObj == null ? void 0 : packageJsonObj.dependencies) == null ? void 0 : _a["@umijs/max"]) {
       return "umi";
     }
+    if (((_b = packageJsonObj == null ? void 0 : packageJsonObj.dependencies) == null ? void 0 : _b["@vue/cli-service"]) || ((_c = packageJsonObj == null ? void 0 : packageJsonObj.devDependencies) == null ? void 0 : _c["@vue/cli-service"])) {
+      return "vue2";
+    }
   } catch (e) {
-    return null;
+    import_utils.logger.error(e.message);
   }
+  return "unknown";
 }
 function getMinVersion(jsonPath, depName) {
   var _a, _b;
@@ -60,5 +68,6 @@ function getMinVersion(jsonPath, depName) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getMinVersion,
-  getRepoType
+  getRepoType,
+  isRepoTypeSupported
 });

package/dist/cjs/util/shared/gitDiffTool.d.ts

@@ -1,11 +1,44 @@
 import { generateGitDiffReport } from "../report_util/generateGitDiffReport";
-export type CloneType = 'ssh' | 'token';
 export declare function cloneGitRepoAndGetDiff(gitRepoUrl: string, branchName: string, extra?: {
-    cloneType?: CloneType;
     token?: string;
+    jsonKeys?: (keyof Awaited<ReturnType<typeof cloneGitRepoAndGetDiff>>)[];
 }): Promise<{
-    [k: string]: string[];
-} | undefined>;
+    reports: {
+        dangerIdentifiers: string[];
+        topEffectedExportsAdded: string[];
+        topEffectedExportsRemoved: string[];
+        blockReports: {
+            diff_txt: string[];
+            infos: {
+                causeBy: string;
+                effectsUpstream: string[];
+                occupations: string[];
+                effectsDownstream: string[];
+            }[];
+        }[];
+        type: "modify" | "add" | "delete";
+        filesDependsOnMe: string[];
+        undefinedIdentifiers: string[];
+        filePath: string;
+    }[];
+    dependenceJson: {
+        import2export: Record<string, string>;
+        export2export: Record<string, string>;
+        mapFilePathToExportAllSources: Record<string, string[]>;
+        indirectExportMembers: Record<string, string>;
+    };
+    effectedCode: Record<string, any>;
+    upstreamDependenceJson: {};
+    repoType: string;
+    message: string;
+} | {
+    effectedCode: Record<string, any>;
+    upstreamDependenceJson: {};
+    repoType: string;
+    message: any;
+    reports?: undefined;
+    dependenceJson?: undefined;
+}>;
 export declare function gitDiffTool(arg: {
     gitRepoUrl: string;
     baseBranch: string;
@@ -13,12 +46,17 @@ export declare function gitDiffTool(arg: {
     tempDirPath: string;
     generateFile: Parameters<typeof generateGitDiffReport>[0]['generateFile'];
 }): Promise<{
-    mdContent: string;
-    dependenceJson: Record<string, any>;
-    upstreamDependenceJson: Record<string, any>;
+    dependenceJson: {
+        import2export: Record<string, string>;
+        export2export: Record<string, string>;
+        mapFilePathToExportAllSources: Record<string, string[]>;
+        indirectExportMembers: Record<string, string>;
+    };
     partialDependenceJson: Record<string, any>;
     reports: {
         dangerIdentifiers: string[];
+        topEffectedExportsAdded: string[];
+        topEffectedExportsRemoved: string[];
         blockReports: {
             diff_txt: string[];
             infos: {

package/dist/cjs/util/shared/gitDiffTool.js

@@ -44,32 +44,58 @@ var import_umi4ProjectUtil = require("./umi4ProjectUtil");
 var import_generateGitDiffReport = require("../report_util/generateGitDiffReport");
 var import_vueProjectUtil = require("./vueProjectUtil");
 var import__ = require("../../index");
-var import_dayjs = __toESM(require("dayjs"));
 var import_fs = require("fs");
 var import_format_git_diff_content = require("../format_git_diff_content");
 var import_gitUtil = require("./gitUtil");
+var import_perf_hooks = require("perf_hooks");
+var import_createDependenceMap = require("../report_util/createDependenceMap");
+var import_collectUpstreamFiles = __toESM(require("./collectUpstreamFiles"));
+var import_filterEffectedCode = __toESM(require("../report_util/filterEffectedCode"));
+var import_report_util = require("../report_util");
+var import_createRandomStr = __toESM(require("../createRandomStr"));
 async function cloneGitRepoAndGetDiff(gitRepoUrl, branchName, extra = {}) {
-  const { token } = extra;
-  const today = (0, import_dayjs.default)().format("YYYYMDD_HHmmss") + Math.random().toString(36).slice(-5);
+  import_perf_hooks.performance.mark("stage 0");
+  const { token, jsonKeys = ["upstreamDependenceJson"] } = extra;
+  const today = (0, import_createRandomStr.default)();
   import_utils.logger.ready("准备生成临时工作目录...");
   const [err] = await (0, import_await_to_js.default)(import_utils.execa.execa(`rm -rf ${today}`, { shell: true }));
   if (err) {
     import_utils.logger.error("临时目录删除失败");
   }
-  await import_utils.execa.execa(`mkdir -p ${today}`, { shell: true });
+  let stderr, failed;
+  ({ stderr, failed } = await import_utils.execa.execa(`mkdir -p ${today}`, { shell: true }));
+  (0, import_handleExecaError.handleExecaError)({ failed, stderr });
   import_utils.logger.info("临时目录建立完成");
+  let upstreamDependenceJson = {};
+  let dependenceJson = {
+    indirectExportMembers: {},
+    import2export: {},
+    export2export: {},
+    mapFilePathToExportAllSources: {}
+  };
+  let effectedCode = {};
+  let reports = [];
   try {
-    let stderr, failed;
     import_utils.logger.ready(`准备clone 源代码到临时目录下的 ${today}/${import_constants.TARGET} 文件夹`);
     const repoUrl = (0, import_parseGitLabDiffUril.getGitRepoUrlByToken)(gitRepoUrl, token || "");
+    import_perf_hooks.performance.mark("stage 1");
     await (0, import_gitUtil.cloneRepoWithBranchAndDefault)(repoUrl, branchName, (0, import_path.join)(today, import_constants.TARGET));
+    import_perf_hooks.performance.mark("stage 2");
+    import_utils.logger.info(`stage 1 --> stage 2 耗时: ${import_perf_hooks.performance.measure("stage 1 --> stage 2", "stage 1", "stage 2").duration}ms`);
+    await (0, import_gitUtil.cloneRepoWithBranchAndDefault)(repoUrl, "master", (0, import_path.join)(today, import_constants.SOURCE));
+    import_perf_hooks.performance.mark("stage 3");
+    import_utils.logger.info(`stage 2 --> stage 3 耗时: ${import_perf_hooks.performance.measure("stage 2 --> stage 3", "stage 2", "stage 3").duration}ms`);
     import_utils.logger.ready("准备生成git_diff.txt文件");
     ({ stderr, failed } = await import_utils.execa.execa(`cd ${today}/${import_constants.TARGET} && git diff master..${branchName} --unified=0 --output=${import__.gitDiffFileName}`, { shell: true }));
+    import_perf_hooks.performance.mark("stage 4");
+    import_utils.logger.info(`stage 3 --> stage 4 耗时: ${import_perf_hooks.performance.measure("stage 3 --> stage 4", "stage 3", "stage 4").duration}ms`);
     (0, import_handleExecaError.handleExecaError)({ failed, stderr });
     const repoType = await (0, import_getRepoSupportFlag.getRepoType)((0, import_path.join)(process.cwd(), today, import_constants.TARGET, "package.json"));
     import_utils.logger.info(`项目类型为: ${repoType}`);
     if (repoType === "umi") {
-      const { madgeResult, shellExeResult } = await (0, import_umi4ProjectUtil.umi4SetUp)({ targetDirPath: (0, import_path.join)(process.cwd(), today, import_constants.TARGET) });
+      const { madgeResult, shellExeResult, parsedAlias } = await (0, import_umi4ProjectUtil.umi4SetUp)({ targetDirPath: (0, import_path.join)(process.cwd(), today, import_constants.TARGET), invokeType: "remote" });
+      import_perf_hooks.performance.mark("stage 5");
+      import_utils.logger.info(`stage 4 --> stage 5 耗时: ${import_perf_hooks.performance.measure("stage 4 --> stage 5", "stage 4", "stage 5").duration}ms`);
       ({ stderr, failed } = shellExeResult);
       (0, import_handleExecaError.handleExecaError)({ failed, stderr });
       const targetDirPath = (0, import_path.join)(process.cwd(), today, import_constants.TARGET);
@@ -78,11 +104,47 @@ async function cloneGitRepoAndGetDiff(gitRepoUrl, branchName, extra = {}) {
       const usingFileNoPrefix = Object.keys(madgeResult.tree);
       const groupGitDiffLines = gitDiffDetail.filter((item) => usingFileNoPrefix.includes(item.filePath));
       const changedFilePaths = groupGitDiffLines.map((item) => item.filePath);
-      const upstreamDependenceJson = Object.fromEntries(changedFilePaths.map((p) => [p, madgeResult.depends(p)]));
-      return upstreamDependenceJson;
+      upstreamDependenceJson = Object.fromEntries(changedFilePaths.map((p) => [p, madgeResult.depends(p)]));
+      const absPathPrefix = targetDirPath + "/";
+      const modifiedFilePaths = gitDiffDetail.map((item) => item.filePath);
+      import_perf_hooks.performance.mark("stage 6");
+      import_utils.logger.info(`stage 5 --> stage 6 耗时: ${import_perf_hooks.performance.measure("stage 5 --> stage 6", "stage 5", "stage 6").duration}ms`);
+      const effectedFilePaths = (0, import_collectUpstreamFiles.default)(madgeResult, modifiedFilePaths).map((item) => (0, import_utils.winPath)((0, import_path.join)(absPathPrefix, item)));
+      import_perf_hooks.performance.mark("stage 7");
+      import_utils.logger.info(`stage 6 --> stage 7 耗时: ${import_perf_hooks.performance.measure("stage 6 --> stage 7", "stage 6", "stage 7").duration}ms`);
+      if (jsonKeys.includes("dependenceJson")) {
+        dependenceJson = (0, import_createDependenceMap.createExportedNameToReferenceLocalSet)(effectedFilePaths, parsedAlias, absPathPrefix, Object.keys(madgeResult.tree));
+      }
+      import_perf_hooks.performance.mark("stage 8");
+      import_utils.logger.info(`stage 7 --> stage 8 耗时: ${import_perf_hooks.performance.measure("stage 7 --> stage 8", "stage 7", "stage 8").duration}ms`);
+      if (jsonKeys.includes("reports")) {
+        reports = (0, import_report_util.createDetectReport)({ groupGitDiffLines, tree: madgeResult.tree, absPathPrefix });
+      }
+      import_perf_hooks.performance.mark("stage 9");
+      import_utils.logger.info(`stage 8 --> stage 9 耗时: ${import_perf_hooks.performance.measure("stage 8 --> stage 9", "stage 8", "stage 9").duration}ms`);
+      if (jsonKeys.includes("effectedCode")) {
+        effectedCode = (0, import_filterEffectedCode.default)(reports, dependenceJson);
+      }
+      import_perf_hooks.performance.mark("stage 10");
+      import_utils.logger.info(`stage 9 --> stage 10 耗时: ${import_perf_hooks.performance.measure("stage 9 --> stage 10", "stage 9", "stage 10").duration}ms`);
+      import_utils.logger.info(`total 耗时: ${import_perf_hooks.performance.measure("stage 0 --> stage 10", "stage 0", "stage 10").duration}ms`);
     }
+    return {
+      reports,
+      dependenceJson,
+      effectedCode,
+      upstreamDependenceJson,
+      repoType,
+      message: ""
+    };
   } catch (error) {
     import_utils.logger.error(error);
+    return {
+      effectedCode,
+      upstreamDependenceJson,
+      repoType: "",
+      message: error.message
+    };
   } finally {
     (0, import_utils.rimraf)((0, import_path.join)(process.cwd(), today), () => {
       import_utils.logger.info("临时目录已删除");
@@ -99,45 +161,34 @@ async function gitDiffTool(arg) {
   await import_utils.execa.execa(`mkdir -p ${today}`, { shell: true });
   import_utils.logger.info("临时目录建立完成");
   try {
-    import_utils.logger.ready(`准备clone 源代码到临时目录下的 ${import_constants.TARGET} 文件夹`);
+    import_utils.logger.ready(`准备clone 源代码 分支：${branchName} 到临时目录下的 ${import_constants.TARGET} 文件夹`);
+    await (0, import_gitUtil.cloneRepoWithBranchAndDefault)(gitUrl, branchName, (0, import_path.join)(process.cwd(), today, import_constants.TARGET));
     let stderr, failed;
-    ({ stderr, failed } = await import_utils.execa.execa(`git clone ${gitUrl} ${today}/${import_constants.TARGET}`, { shell: true }));
-    (0, import_handleExecaError.handleExecaError)({ failed, stderr });
     import_utils.logger.info("源代码clone完成");
     import_utils.logger.wait("检测项目类型");
     const repoType = await (0, import_getRepoSupportFlag.getRepoType)((0, import_path.join)(process.cwd(), today, import_constants.TARGET, "package.json"));
     import_utils.logger.info(`项目类型为: ${repoType}`);
-    if (!repoType) {
+    if (!(0, import_getRepoSupportFlag.isRepoTypeSupported)(repoType)) {
       import_utils.logger.error("该项目不支持检测");
       (0, import_utils.rimraf)((0, import_path.join)(process.cwd(), today), () => {
         import_utils.logger.info("临时目录已删除");
       });
       return;
     }
-    import_utils.logger.ready(`准备clone 源代码到临时目录下的 ${import_constants.SOURCE} 文件夹`);
-    ({ stderr, failed } = await import_utils.execa.execa(`git clone ${gitUrl} ${today}/${import_constants.SOURCE}`, { shell: true }));
-    (0, import_handleExecaError.handleExecaError)({ failed, stderr });
-    import_utils.logger.info("源代码clone完成");
-    if (baseBranch !== "master") {
-      import_utils.logger.ready("准备切换到基准分支");
-      ({ stderr, failed } = await import_utils.execa.execa(`cd ${today}/${import_constants.SOURCE} && git fetch origin ${baseBranch}:${baseBranch} && git checkout ${baseBranch}`, { shell: true }));
-      (0, import_handleExecaError.handleExecaError)({ failed, stderr });
-      import_utils.logger.info("源代码切换到基准分支完成");
-    }
-    import_utils.logger.ready("准备切换到目标分支");
-    ({ stderr, failed } = await import_utils.execa.execa(`cd ${today}/${import_constants.TARGET} && git fetch origin ${branchName}:${branchName} && git checkout ${branchName}`, { shell: true }));
-    (0, import_handleExecaError.handleExecaError)({ failed, stderr });
-    import_utils.logger.info("分支切换完成");
+    import_utils.logger.ready(`准备clone 源代码 分支：master 到临时目录下的 ${import_constants.SOURCE} 文件夹`);
+    await (0, import_gitUtil.cloneRepoWithBranchAndDefault)(gitUrl, "master", (0, import_path.join)(process.cwd(), today, import_constants.SOURCE));
+    import_utils.logger.info(`分支 ${branchName} 代码 clone 完成`);
     import_utils.logger.ready("准备生成git_diff.txt文件");
     ({ stderr, failed } = await import_utils.execa.execa(`cd ${today}/${import_constants.TARGET} && git diff ${baseBranch}..${branchName} --unified=0 --output=${import__.gitDiffFileName}`, { shell: true }));
     (0, import_handleExecaError.handleExecaError)({ failed, stderr });
     import_utils.logger.info("git_diff.txt文件生成完成");
     if (repoType === "umi") {
-      const { madgeResult, shellExeResult, parsedAlias } = await (0, import_umi4ProjectUtil.umi4SetUp)({ targetDirPath: (0, import_path.join)(process.cwd(), today, import_constants.TARGET) });
+      const { madgeResult, shellExeResult, parsedAlias } = await (0, import_umi4ProjectUtil.umi4SetUp)({ targetDirPath: (0, import_path.join)(process.cwd(), today, import_constants.TARGET), invokeType: "local" });
       ({ stderr, failed } = shellExeResult);
       (0, import_handleExecaError.handleExecaError)({ failed, stderr });
-      return await (0, import_generateGitDiffReport.generateGitDiffReport)({ madgeResult, parsedAlias, targetDirPath: (0, import_path.join)(process.cwd(), today, import_constants.TARGET), generateFile });
-    } else if (repoType === "vue") {
+      const reports = await (0, import_generateGitDiffReport.generateGitDiffReport)({ madgeResult, parsedAlias, targetDirPath: (0, import_path.join)(process.cwd(), today, import_constants.TARGET), generateFile });
+      return reports;
+    } else if (repoType === "vue2") {
       const { madgeResult, shellExeResult, parsedAlias } = await (0, import_vueProjectUtil.vueSetUp)({ targetDir: `${today}/${import_constants.TARGET}` });
       ({ stderr, failed } = shellExeResult);
       (0, import_handleExecaError.handleExecaError)({ failed, stderr });

package/dist/cjs/util/shared/gitUtil.d.ts

@@ -6,3 +6,7 @@
  * @returns {Promise<string>} 克隆目录路径
  */
 export declare function cloneRepoWithBranchAndDefault(repoUrl: string, targetBranch: string, targetDir: string): Promise<string>;
+/**
+ * 执行 baseBranch  和 targetBranch 的 diff
+*/
+export declare function execGitDiff(targetDir: string, baseBranch: string, targetBranch: string): Promise<any>;

package/dist/cjs/util/shared/gitUtil.js

@@ -19,9 +19,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/util/shared/gitUtil.ts
 var gitUtil_exports = {};
 __export(gitUtil_exports, {
-  cloneRepoWithBranchAndDefault: () => cloneRepoWithBranchAndDefault
+  cloneRepoWithBranchAndDefault: () => cloneRepoWithBranchAndDefault,
+  execGitDiff: () => execGitDiff
 });
 module.exports = __toCommonJS(gitUtil_exports);
+var import__ = require("../../index");
 var simpleGit = require("simple-git");
 async function cloneRepoWithBranchAndDefault(repoUrl, targetBranch, targetDir) {
   try {
@@ -45,7 +47,21 @@ async function cloneRepoWithBranchAndDefault(repoUrl, targetBranch, targetDir) {
     throw error;
   }
 }
+async function execGitDiff(targetDir, baseBranch, targetBranch) {
+  try {
+    const repoGit = simpleGit(targetDir);
+    await repoGit.checkout(targetBranch);
+    await repoGit.pull("origin", targetBranch);
+    const diffFiles = await repoGit.diffSummary([baseBranch, "--unified=0", `--output=${import__.gitDiffFileName}`]);
+    console.log(`${targetBranch} 与 ${baseBranch} 的差异：`, diffFiles);
+    return diffFiles;
+  } catch (error) {
+    console.error(`获取差异失败：${error.message}`);
+    throw error;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  cloneRepoWithBranchAndDefault
+  cloneRepoWithBranchAndDefault,
+  execGitDiff
 });

package/dist/cjs/util/shared/umi4ProjectUtil.d.ts

@@ -1,6 +1,7 @@
 import { execa } from "@umijs/utils";
-export declare function umi4SetUp({ targetDirPath }: {
+export declare function umi4SetUp({ targetDirPath, invokeType }: {
     targetDirPath: string;
+    invokeType: 'local' | 'remote';
 }): Promise<{
     shellExeResult: execa.ExecaReturnValue<string>;
     madgeResult: import("../report_util/getMadgeInstance").IMadgeInstance;

package/dist/cjs/util/shared/umi4ProjectUtil.js

@@ -35,14 +35,12 @@ var userAliasGetter = (cwd, appData) => {
     "@umijs/max": "@@/exports"
   };
 };
-async function umi4SetUp({ targetDirPath }) {
-  import_utils.logger.info(`正在删除 yarn.lock 文件...`);
-  const yarnLockPath = (0, import_path.join)(targetDirPath, "yarn.lock");
-  if ((0, import_fs.existsSync)(yarnLockPath)) {
-    await import_utils.execa.execa(`mv ${yarnLockPath} ${(0, import_path.join)(targetDirPath, "yarn.lock.bak")}`, { shell: true });
-  }
-  import_utils.logger.info(`正在安装 @umijs/max 并执行 setup 脚本...`);
-  const shellExeResult = await import_utils.execa.execa(`cd ${targetDirPath} && npm uninstall @umijs/max && npm install @umijs/max && npx max setup`, { shell: true });
+async function getUmiInvokeResult(targetDirPath, invokeType) {
+  return await import_utils.execa.execa(`cd ${targetDirPath} && npx max setup`, { shell: true });
+}
+async function umi4SetUp({ targetDirPath, invokeType }) {
+  import_utils.logger.info(`正在执行 setup 脚本...`);
+  const shellExeResult = await getUmiInvokeResult(targetDirPath, invokeType);
   const tsconfig = await import_utils.tsconfigPaths.loadConfig(targetDirPath);
   let appData = { config: null };
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-code-detector",
-  "version": "0.0.43",
+  "version": "0.0.47",
   "description": "",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",
@@ -31,7 +31,8 @@
     "@types/crypto-js": "^4.2.2",
     "@types/lodash": "^4.17.20",
     "@types/madge": "^5.0.3",
-    "father": "^4.6.3"
+    "father": "^4.6.3",
+    "tsx": "^4.20.6"
   },
   "dependencies": {
     "@babel/parser": "^7.28.3",

package/bin/eslintOutput.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-require('../dist/cjs/index').getEslintCheckResult();

package/dist/cjs/sh/detect.sh

@@ -1,15 +0,0 @@
-#!/bin/sh
-time=$(date "+%Y%-m%d%H%M%S")
-mkdir -p $time
-cd $time
-
-git clone $1 target
-cd target
-yarn install
-
-git fetch origin $2:$2
-git checkout $2
-
-git diff master..$2 --unified=0 --output=git_diff.txt
-cd ..
-git clone $1 source