feat: filter hotspots by score

Author: manfredsteyer

backend/src/index.ts

@@ -12,7 +12,7 @@ import { calcModuleInfo } from "./services/module-info";
 import { calcTeamAlignment } from "./services/team-alignment";
 import { openSync } from './utils/open';
 import { ensureConfig } from "./infrastructure/config";
-import { findHotspots, HotspotCriteria } from "./services/hotspot";
+import { findHotspotFiles, HotspotCriteria } from "./services/hotspot";
 
 const options = parseOptions(process.argv.slice(2));
 
@@ -94,10 +94,10 @@ app.get("/api/team-alignment", async (req, res) => {
 });
 
 app.get("/api/hotspots", async (req, res) => {
-  // const byUser = Boolean(req.query.byUser);
+  const minScore = Number(req.query.minScore) || -1;
 
   try {
-    const result = await findHotspots(options);
+    const result = await findHotspotFiles({minScore: minScore}, options);
     res.json(result);
   } catch (e) {
     console.log('error', e);

backend/src/services/hotspot.ts

@@ -4,48 +4,86 @@ import { parseGitLog } from "../utils/git-parser";
 import * as fs from 'fs';
 import { calcComplexity } from "../utils/complexity";
 
+export type Hotspot = {
+  commits: number,
+  changedLines: number,
+  complexity: number,
+  score: number,
+};
+
 // tuple to reduce payload size
-export type Hotspot = [
+export type FlatHotspot = {
+  fileName: string,
   commits: number,
   changedLines: number,
   complexity: number,
-];
+  score: number,
+};
 
 export type HotspotResult = {
-  hotspots: Record<string, Hotspot>;
+  hotspots: FlatHotspot[];
 };
 
 export type HotspotCriteria = {
-  minCommits: number;
-  minChangedLines: number;
-  minComplexity: number;
+  // minCommits: number;
+  // minChangedLines: number;
+  // minComplexity: number;
+  minScore: number,
 };
 
-export async function findHotspots(options: Options): Promise<HotspotResult> {
-  const result: HotspotResult = { hotspots: {} };
+export async function findHotspotFiles(criteria: HotspotCriteria, options: Options): Promise<HotspotResult> {
+  const hotspots: Record<string, Hotspot> = await _findHotspots(options);
+
+  const filtered: FlatHotspot[] = []; 
+  for (const fileName of Object.keys(hotspots)) {
+    const hotspot = hotspots[fileName];
+    hotspot.score = hotspot.complexity === -1 ? -1 : hotspot.complexity * hotspot.commits;
+    if (hotspot.score >= criteria.minScore) {
+      filtered.push({ fileName, ...hotspot });
+    }
+  }
+
+  return { hotspots: filtered };
+}
+
+// export async function aggregateHotspots(criteria: HotspotCriteria, options: Options): Promise<HotspotResult> {
+//   const hotspots: Record<string, Hotspot> = await _findHotspots(options);
+
+//   const config = loadConfig();
+
+//   return { hotspots: filtered };
+// }
+
+async function _findHotspots(options: Options) {
+  const hotspots: Record<string, Hotspot> = {};
 
   await parseGitLog((entry) => {
     for (const change of entry.body) {
       let hotspot: Hotspot;
-      if (!result.hotspots[change.path]) {
+      if (!hotspots[change.path]) {
 
         let cc = -1;
         const filePath = path.join(options.path, change.path);
         if (filePath.endsWith('.ts') && fs.existsSync(filePath)) {
           cc = calcComplexity(filePath);
         }
 
-        hotspot = [0, 0, cc];
-        result.hotspots[change.path] = hotspot;
+        hotspot = {
+          commits: 0,
+          changedLines: 0,
+          complexity: -1,
+          score: 0,
+        };
+
+        hotspots[change.path] = hotspot;
       } else {
-        hotspot = result.hotspots[change.path];
+        hotspot = hotspots[change.path];
       }
 
-      hotspot[0]++;
-      hotspot[1] += change.linesAdded + change.linesRemoved;
-
+      hotspot.commits++;
+      hotspot.changedLines += change.linesAdded + change.linesRemoved;
     }
   });
-
-  return result;
+  return hotspots;
 }
+