@getcodesentinel/codesentinel 1.19.0 → 1.20.0

package/README.md

@@ -233,8 +233,9 @@ Notes:
 
 - `likely_merge` (default) may merge multiple emails that likely belong to the same person based on repository history.
 - `strict_email` treats each canonical email as a distinct author, which avoids false merges but can split the same person across multiple emails.
-- Git mailmap is enabled (`git log --use-mailmap`). Put `.mailmap` in the repository being analyzed (the `codesentinel analyze [path]` target). Git will then deterministically unify known aliases before CodeSentinel computes `authorDistribution`.
-- `authorDistribution` returns whichever identity mode is selected.
+- Git mailmap is enabled (`git log --use-mailmap`). Put `.mailmap` in the repository being analyzed (the `codesentinel analyze [path]` target). Git will then deterministically unify known aliases before CodeSentinel computes ownership distributions.
+- Evolution output includes both `authorDistributionByCommits` and `authorDistributionByChurn`, plus their derived `topAuthorShare...` and `busFactor...` fields.
+- Current scoring continues to use the commit-weighted ownership view (`...ByCommits`).
 - Logs are emitted to `stderr` and JSON output is written to `stdout`, so CI redirection still works.
 - You can set a default log level with `CODESENTINEL_LOG_LEVEL` (`silent|error|warn|info|debug`).
 - At `info`/`debug`, structural, evolution, and dependency stages report progress so long analyses are observable.

package/dist/index.js

@@ -3702,6 +3702,7 @@ var ANSI2 = {
   cyan: "\x1B[36m",
   green: "\x1B[32m"
 };
+var PROMPT_PADDING = "  ";
 var renderMenu = (currentVersion, actions, selectedIndex) => {
   const optionLabels = actions.map((action, index) => `${index + 1}. ${action.label}`);
   const labelWidth = optionLabels.reduce((max, label) => Math.max(max, label.length), 0);
@@ -3732,6 +3733,46 @@ var hideCursor2 = () => {
 var showCursor2 = () => {
   stderr2.write("\x1B[?25h");
 };
+var pipeWithPadding = (stream, target, padding) => {
+  if (stream === null) {
+    return;
+  }
+  stream.setEncoding("utf8");
+  let buffer = "";
+  let needsPrefix = true;
+  const writeChunk = (chunk) => {
+    let start = 0;
+    while (start < chunk.length) {
+      if (needsPrefix) {
+        target.write(padding);
+        needsPrefix = false;
+      }
+      const newlineIndex = chunk.indexOf("\n", start);
+      if (newlineIndex === -1) {
+        target.write(chunk.slice(start));
+        return;
+      }
+      target.write(chunk.slice(start, newlineIndex + 1));
+      needsPrefix = true;
+      start = newlineIndex + 1;
+    }
+  };
+  stream.on("data", (chunk) => {
+    buffer += chunk;
+    const lastNewlineIndex = buffer.lastIndexOf("\n");
+    if (lastNewlineIndex === -1) {
+      return;
+    }
+    writeChunk(buffer.slice(0, lastNewlineIndex + 1));
+    buffer = buffer.slice(lastNewlineIndex + 1);
+  });
+  stream.on("end", () => {
+    if (buffer.length > 0) {
+      writeChunk(buffer);
+      buffer = "";
+    }
+  });
+};
 var promptSelection = async (currentVersion, actions) => {
   if (!stdin2.isTTY || !stderr2.isTTY || typeof stdin2.setRawMode !== "function") {
     return "exit";
@@ -3788,46 +3829,99 @@ var createPrompt = () => createPromisesInterface({
   output: stderr2
 });
 var promptText = async (prompt, label, defaultValue) => {
-  const suffix = defaultValue === void 0 ? "" : ` [${defaultValue}]`;
-  const answer = await prompt.question(
-    `${label}${suffix}: `
-  );
+  const suffix = defaultValue === void 0 || defaultValue.length === 0 ? "" : ` [${defaultValue}]`;
+  let answer;
+  try {
+    answer = await prompt.question(
+      `${PROMPT_PADDING}${label}${suffix}: `
+    );
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ABORT_ERR") {
+      stderr2.write("\n");
+      return null;
+    }
+    throw error;
+  }
   const trimmed = answer.trim();
   return trimmed.length > 0 ? trimmed : defaultValue ?? "";
 };
+var renderDependencyRiskPrompt = (errorMessage) => {
+  clearTerminal();
+  stderr2.write(`${PROMPT_PADDING}${ANSI2.bold}Scan dependency risk${ANSI2.reset}
+`);
+  if (errorMessage !== void 0) {
+    stderr2.write(`
+${PROMPT_PADDING}${errorMessage}
+`);
+  }
+  stderr2.write("\n");
+};
 var buildDependencyRiskArgs = async () => {
   const prompt = createPrompt();
   try {
-    const dependency = await promptText(prompt, "Dependency spec", "");
-    if (dependency.length === 0) {
-      stderr2.write("A dependency spec is required.\n");
-      return null;
+    let errorMessage;
+    while (true) {
+      renderDependencyRiskPrompt(errorMessage);
+      const dependency = await promptText(prompt, "Package name");
+      if (dependency === null) {
+        return { kind: "cancel" };
+      }
+      if (dependency.length === 0) {
+        errorMessage = "A package name is required.";
+        continue;
+      }
+      return {
+        kind: "run",
+        args: ["dependency-risk", dependency]
+      };
     }
-    return ["dependency-risk", dependency];
   } finally {
     prompt.close();
   }
 };
 var waitForReturnToMenu = async () => {
-  const prompt = createPromisesInterface({
-    input: stdin2,
-    output: stderr2
-  });
-  try {
-    await prompt.question("Press enter to return to the menu...");
-  } finally {
-    prompt.close();
+  if (!stdin2.isTTY || !stderr2.isTTY || typeof stdin2.setRawMode !== "function") {
+    return;
   }
+  stderr2.write(`
+${PROMPT_PADDING}Press enter to return to the menu...`);
+  await new Promise((resolve6) => {
+    emitKeypressEvents2(stdin2);
+    const previousRawMode = stdin2.isRaw;
+    const cleanup = () => {
+      stdin2.off("keypress", onKeypress);
+      stdin2.pause();
+      stdin2.setRawMode(previousRawMode);
+      showCursor2();
+      stderr2.write("\n");
+      resolve6();
+    };
+    const onKeypress = (_str, key) => {
+      if (key.ctrl === true && key.name === "c") {
+        cleanup();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        cleanup();
+      }
+    };
+    hideCursor2();
+    stdin2.on("keypress", onKeypress);
+    stdin2.setRawMode(true);
+    stdin2.resume();
+  });
 };
 var runCliCommand = async (scriptPath2, args) => {
   return await new Promise((resolve6, reject) => {
     const child = spawn2(process.execPath, [...process.execArgv, scriptPath2, ...args], {
-      stdio: "inherit",
+      stdio: ["inherit", "pipe", "pipe"],
       env: {
         ...process.env,
         CODESENTINEL_NO_UPDATE_NOTIFIER: "1"
       }
     });
+    pipeWithPadding(child.stdout, stdout, PROMPT_PADDING);
+    pipeWithPadding(child.stderr, stderr2, PROMPT_PADDING);
     child.on("error", (error) => {
       reject(error);
     });
@@ -3838,34 +3932,35 @@ var runCliCommand = async (scriptPath2, args) => {
 };
 var runInteractiveCliMenu = async (input) => {
   if (!stdin2.isTTY || !stderr2.isTTY || !stdout.isTTY) {
-    stderr2.write("Interactive menu requires a TTY.\n");
+    stderr2.write(`${PROMPT_PADDING}Interactive menu requires a TTY.
+`);
     return 1;
   }
   const actions = [
     {
       label: "Run overview",
       description: "combined analyze + explain + report",
-      commandBuilder: () => ["run"]
+      commandBuilder: () => ({ kind: "run", args: ["run"] })
     },
     {
       label: "Analyze repository",
       description: "structural and health scoring summary",
-      commandBuilder: () => ["analyze"]
+      commandBuilder: () => ({ kind: "run", args: ["analyze"] })
     },
     {
       label: "Explain hotspots",
       description: "top findings in markdown by default",
-      commandBuilder: () => ["explain", "--format", "md"]
+      commandBuilder: () => ({ kind: "run", args: ["explain", "--format", "md"] })
     },
     {
       label: "Generate report",
       description: "create a full report for a repository",
-      commandBuilder: () => ["report", "--format", "md"]
+      commandBuilder: () => ({ kind: "run", args: ["report", "--format", "md"] })
     },
     {
       label: "Run policy check",
       description: "execute governance gates",
-      commandBuilder: () => ["check"]
+      commandBuilder: () => ({ kind: "run", args: ["check"] })
     },
     {
       label: "Scan dependency risk",
@@ -3881,18 +3976,18 @@ var runInteractiveCliMenu = async (input) => {
     }
     const selectedAction = actions[selectedIndex];
     if (selectedAction === void 0) {
-      stderr2.write("\n");
+      stderr2.write(`
+${PROMPT_PADDING}`);
       return 1;
     }
-    const args = await selectedAction.commandBuilder();
-    if (args === null) {
-      await waitForReturnToMenu();
+    const actionResult = await selectedAction.commandBuilder();
+    if (actionResult.kind === "cancel") {
       continue;
     }
-    const exitCode = await runCliCommand(input.scriptPath, args);
+    const exitCode = await runCliCommand(input.scriptPath, actionResult.args);
     if (exitCode !== 0) {
       stderr2.write(`
-Command exited with code ${exitCode}.
+${PROMPT_PADDING}Command exited with code ${exitCode}.
 `);
     } else {
       stderr2.write("\n");
@@ -4588,6 +4683,26 @@ var finalizeAuthorDistribution = (authorCommits) => {
     share: round44(commits / totalCommits)
   })).sort((a, b) => b.commits - a.commits || a.authorId.localeCompare(b.authorId));
 };
+var finalizeAuthorChurnDistribution = (authorChurn) => {
+  const entries = [...authorChurn.entries()].map(([authorId, churn]) => {
+    const churnAdded = churn.churnAdded;
+    const churnDeleted = churn.churnDeleted;
+    return {
+      authorId,
+      churnAdded,
+      churnDeleted,
+      churnTotal: churnAdded + churnDeleted
+    };
+  });
+  const totalChurn = entries.reduce((sum, entry) => sum + entry.churnTotal, 0);
+  if (totalChurn === 0) {
+    return [];
+  }
+  return entries.map((entry) => ({
+    ...entry,
+    share: round44(entry.churnTotal / totalChurn)
+  })).sort((a, b) => b.churnTotal - a.churnTotal || a.authorId.localeCompare(b.authorId));
+};
 var buildCouplingMatrix = (coChangeByPair, fileCommitCount, consideredCommits, skippedLargeCommits, maxCouplingPairs) => {
   const allPairs = [];
   for (const [key, coChangeCommits] of coChangeByPair.entries()) {
@@ -4656,10 +4771,19 @@ var computeRepositoryEvolutionSummary = (targetPath, commits, config) => {
         recentCommitCount: 0,
         churnAdded: 0,
         churnDeleted: 0,
-        authors: /* @__PURE__ */ new Map()
+        authorsByCommits: /* @__PURE__ */ new Map(),
+        authorsByChurn: /* @__PURE__ */ new Map()
       };
       current.churnAdded += fileChange.additions;
       current.churnDeleted += fileChange.deletions;
+      const effectiveAuthorId = authorAliasById.get(commit.authorId) ?? commit.authorId;
+      const authorChurn = current.authorsByChurn.get(effectiveAuthorId) ?? {
+        churnAdded: 0,
+        churnDeleted: 0
+      };
+      authorChurn.churnAdded += fileChange.additions;
+      authorChurn.churnDeleted += fileChange.deletions;
+      current.authorsByChurn.set(effectiveAuthorId, authorChurn);
       fileStats.set(fileChange.filePath, current);
     }
     for (const filePath of uniqueFiles) {
@@ -4672,7 +4796,10 @@ var computeRepositoryEvolutionSummary = (targetPath, commits, config) => {
         current.recentCommitCount += 1;
       }
       const effectiveAuthorId = authorAliasById.get(commit.authorId) ?? commit.authorId;
-      current.authors.set(effectiveAuthorId, (current.authors.get(effectiveAuthorId) ?? 0) + 1);
+      current.authorsByCommits.set(
+        effectiveAuthorId,
+        (current.authorsByCommits.get(effectiveAuthorId) ?? 0) + 1
+      );
     }
     const orderedFiles = [...uniqueFiles].sort((a, b) => a.localeCompare(b));
     if (orderedFiles.length > 1) {
@@ -4695,8 +4822,10 @@ var computeRepositoryEvolutionSummary = (targetPath, commits, config) => {
     }
   }
   const files = [...fileStats.entries()].map(([filePath, stats]) => {
-    const authorDistribution = finalizeAuthorDistribution(stats.authors);
-    const topAuthorShare = authorDistribution[0]?.share ?? 0;
+    const authorDistributionByCommits = finalizeAuthorDistribution(stats.authorsByCommits);
+    const authorDistributionByChurn = finalizeAuthorChurnDistribution(stats.authorsByChurn);
+    const topAuthorShareByCommits = authorDistributionByCommits[0]?.share ?? 0;
+    const topAuthorShareByChurn = authorDistributionByChurn[0]?.share ?? 0;
     return {
       filePath,
       commitCount: stats.commitCount,
@@ -4706,9 +4835,18 @@ var computeRepositoryEvolutionSummary = (targetPath, commits, config) => {
       churnTotal: stats.churnAdded + stats.churnDeleted,
       recentCommitCount: stats.recentCommitCount,
       recentVolatility: stats.commitCount === 0 ? 0 : round44(stats.recentCommitCount / stats.commitCount),
-      topAuthorShare,
-      busFactor: computeBusFactor(authorDistribution, config.busFactorCoverageThreshold),
-      authorDistribution
+      topAuthorShareByCommits,
+      busFactorByCommits: computeBusFactor(
+        authorDistributionByCommits,
+        config.busFactorCoverageThreshold
+      ),
+      authorDistributionByCommits,
+      topAuthorShareByChurn,
+      busFactorByChurn: computeBusFactor(
+        authorDistributionByChurn,
+        config.busFactorCoverageThreshold
+      ),
+      authorDistributionByChurn
     };
   }).sort((a, b) => a.filePath.localeCompare(b.filePath));
   const fileCommitCount = new Map(files.map((file) => [file.filePath, file.commitCount]));
@@ -5463,15 +5601,15 @@ var computeRepositoryHealthSummary = (input) => {
     let singleContributorFiles = 0;
     let trackedFiles = 0;
     for (const file of evolutionSourceFiles) {
-      if (file.commitCount <= 0 || file.authorDistribution.length === 0) {
+      if (file.commitCount <= 0 || file.authorDistributionByCommits.length === 0) {
         continue;
       }
       trackedFiles += 1;
-      const dominantShare = clamp01(file.authorDistribution[0]?.share ?? 0);
-      if (file.authorDistribution.length === 1 || dominantShare >= 0.9) {
+      const dominantShare = clamp01(file.authorDistributionByCommits[0]?.share ?? 0);
+      if (file.authorDistributionByCommits.length === 1 || dominantShare >= 0.9) {
         singleContributorFiles += 1;
       }
-      for (const author of file.authorDistribution) {
+      for (const author of file.authorDistributionByCommits) {
         const commits = Math.max(0, author.commits);
         if (commits <= 0) {
           continue;
@@ -6234,7 +6372,7 @@ var computeEvolutionScales = (evolutionByFile, config) => {
       config.quantileClamp.upper
     ),
     busFactor: buildQuantileScale(
-      evolutionFiles.map((metrics) => metrics.busFactor),
+      evolutionFiles.map((metrics) => metrics.busFactorByCommits),
       config.quantileClamp.lower,
       config.quantileClamp.upper
     )
@@ -6423,9 +6561,9 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
         evolutionScales.churnTotal
       );
       volatilityRisk = toUnitInterval(evolutionMetrics.recentVolatility);
-      ownershipConcentrationRisk = toUnitInterval(evolutionMetrics.topAuthorShare);
+      ownershipConcentrationRisk = toUnitInterval(evolutionMetrics.topAuthorShareByCommits);
       busFactorRisk = toUnitInterval(
-        1 - normalizeWithScale(evolutionMetrics.busFactor, evolutionScales.busFactor)
+        1 - normalizeWithScale(evolutionMetrics.busFactorByCommits, evolutionScales.busFactor)
       );
       const evolutionWeights = config.evolutionFactorWeights;
       evolutionFactor = toUnitInterval(
@@ -6482,8 +6620,8 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
         commitCount: evolutionMetrics?.commitCount ?? null,
         churnTotal: evolutionMetrics?.churnTotal ?? null,
         recentVolatility: evolutionMetrics?.recentVolatility ?? null,
-        topAuthorShare: evolutionMetrics?.topAuthorShare ?? null,
-        busFactor: evolutionMetrics?.busFactor ?? null,
+        topAuthorShareByCommits: evolutionMetrics?.topAuthorShareByCommits ?? null,
+        busFactorByCommits: evolutionMetrics?.busFactorByCommits ?? null,
         dependencyAffinity: round46(dependencyAffinity),
         repositoryExternalPressure: round46(dependencyComputation.repositoryExternalPressure),
         structuralAttenuation: round46(structuralAttenuation)
@@ -6551,8 +6689,8 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
             commitCount: context.rawMetrics.commitCount,
             churnTotal: context.rawMetrics.churnTotal,
             recentVolatility: context.rawMetrics.recentVolatility,
-            topAuthorShare: context.rawMetrics.topAuthorShare,
-            busFactor: context.rawMetrics.busFactor
+            topAuthorShareByCommits: context.rawMetrics.topAuthorShareByCommits,
+            busFactorByCommits: context.rawMetrics.busFactorByCommits
           },
           normalizedMetrics: {
             frequencyRisk: context.normalizedMetrics.frequencyRisk,