@monoes/monograph 1.5.6 → 1.5.7

package/src/health/health-grouping.ts

@@ -1,86 +0,0 @@
-export interface HealthGroup {
-  name: string;
-  files: string[];
-  fileCount: number;
-  score: number;
-  grade: string;
-  totalLines: number;
-  unusedExports: number;
-  circularDeps: number;
-}
-
-export interface HealthGrouping {
-  groups: HealthGroup[];
-  totalFiles: number;
-  averageScore: number;
-}
-
-export function groupFilesByOwner(
-  files: Array<{ filePath: string }>,
-  resolveOwner: (filePath: string) => string,
-): Map<string, string[]> {
-  const result = new Map<string, string[]>();
-  for (const { filePath } of files) {
-    const owner = resolveOwner(filePath);
-    const list = result.get(owner);
-    if (list != null) {
-      list.push(filePath);
-    } else {
-      result.set(owner, [filePath]);
-    }
-  }
-  return result;
-}
-
-export function computeGroupScore(
-  files: string[],
-  scoreMap: Map<string, number>,
-): number {
-  const known = files.filter(f => scoreMap.has(f));
-  if (known.length === 0) return 100;
-  const sum = known.reduce((acc, f) => acc + scoreMap.get(f)!, 0);
-  return sum / known.length;
-}
-
-function gradeFromScore(score: number): string {
-  if (score >= 90) return 'A';
-  if (score >= 75) return 'B';
-  if (score >= 60) return 'C';
-  if (score >= 40) return 'D';
-  return 'F';
-}
-
-export function buildHealthGrouping(
-  files: string[],
-  resolveOwner: (filePath: string) => string,
-  scoreMap: Map<string, number>,
-  lineCountMap: Map<string, number>,
-): HealthGrouping {
-  const grouped = groupFilesByOwner(files.map(f => ({ filePath: f })), resolveOwner);
-
-  const groups: HealthGroup[] = [];
-  for (const [owner, ownerFiles] of grouped.entries()) {
-    const score = computeGroupScore(ownerFiles, scoreMap);
-    const totalLines = ownerFiles.reduce((sum, f) => sum + (lineCountMap.get(f) ?? 0), 0);
-    groups.push({
-      name: owner,
-      files: ownerFiles,
-      fileCount: ownerFiles.length,
-      score,
-      grade: gradeFromScore(score),
-      totalLines,
-      unusedExports: 0,
-      circularDeps: 0,
-    });
-  }
-
-  groups.sort((a, b) => b.score - a.score);
-
-  const totalFiles = files.length;
-  const averageScore =
-    groups.length > 0
-      ? groups.reduce((sum, g) => sum + g.score * g.fileCount, 0) / Math.max(totalFiles, 1)
-      : 100;
-
-  return { groups, totalFiles, averageScore };
-}

package/src/health/health-report-types.ts

@@ -1,165 +0,0 @@
-import type { ExceededThreshold, FindingSeverity } from './scores.js';
-import type { TrendDirection, TrendMetric, TrendPoint } from './trend-types.js';
-
-export type HealthGradeLetter = 'A' | 'B' | 'C' | 'D' | 'F';
-
-export const HOTSPOT_SCORE_THRESHOLD = 50.0;
-
-export function letterGrade(score: number): HealthGradeLetter {
-  if (score >= 90) return 'A';
-  if (score >= 75) return 'B';
-  if (score >= 60) return 'C';
-  if (score >= 40) return 'D';
-  return 'F';
-}
-
-export interface HealthScorePenalties {
-  complexity: number;
-  duplication: number;
-  deadCode: number;
-  coupling: number;
-  maintainability: number;
-}
-
-export interface HealthScore {
-  score: number;
-  grade: HealthGradeLetter;
-  penalties: HealthScorePenalties;
-}
-
-export interface HealthFinding {
-  path: string;
-  name: string;
-  line?: number;
-  col?: number;
-  cyclomatic?: number;
-  cognitive?: number;
-  lineCount?: number;
-  paramCount?: number;
-  exceeded?: ExceededThreshold;
-  severity?: FindingSeverity;
-  crap?: number;
-  coveragePct?: number;
-}
-
-export interface FileScore {
-  path: string;
-  maintainabilityIndex?: number;
-  fanIn?: number;
-  fanOut?: number;
-  deadCodeRatio?: number;
-  complexityDensity?: number;
-  crapMax?: number;
-  crapAboveThreshold?: number;
-}
-
-export interface UnitSizeProfile {
-  tiny: number;
-  small: number;
-  medium: number;
-  large: number;
-  huge: number;
-}
-
-export interface IssueCounts {
-  unusedFiles: number;
-  unusedExports: number;
-  unusedTypes: number;
-  privateTypeLeaks: number;
-  unusedDependencies: number;
-  unresolvedImports: number;
-  circularDependencies: number;
-  boundaryViolations: number;
-}
-
-export interface VitalSigns {
-  deadFilePct: number;
-  deadExportPct: number;
-  avgCyclomatic: number;
-  p90Cyclomatic: number;
-  duplicationPct: number;
-  hotspotCount: number;
-  maintainabilityAvg: number;
-  unusedDepCount: number;
-  circularDepCount: number;
-  counts: IssueCounts;
-  unitSizeProfile: UnitSizeProfile;
-  couplingHighPct: number;
-}
-
-export interface RuntimeCoverageEvidence {
-  triggeredFiles: number;
-  totalFiles: number;
-  pct: number;
-}
-
-export type RuntimeCoverageVerdict = 'Sufficient' | 'Low' | 'Missing' | 'Unknown';
-
-export interface RuntimeCoverageSummary {
-  verdict: RuntimeCoverageVerdict;
-  evidence?: RuntimeCoverageEvidence;
-  message?: string;
-}
-
-export interface HealthTrend {
-  comparedTo: TrendPoint;
-  metrics: TrendMetric[];
-  overallDirection: TrendDirection;
-}
-
-export interface HealthReport {
-  score: HealthScore;
-  findings: HealthFinding[];
-  fileScores: FileScore[];
-  vitalSigns?: VitalSigns;
-  hotspots: HealthFinding[];
-  trend?: HealthTrend;
-  runtimeCoverage?: RuntimeCoverageSummary;
-  generatedAt: string;
-  root: string;
-}
-
-export function makeHealthScore(score: number, penalties: Partial<HealthScorePenalties> = {}): HealthScore {
-  return {
-    score: Math.max(0, Math.min(100, score)),
-    grade: letterGrade(score),
-    penalties: {
-      complexity: penalties.complexity ?? 0,
-      duplication: penalties.duplication ?? 0,
-      deadCode: penalties.deadCode ?? 0,
-      coupling: penalties.coupling ?? 0,
-      maintainability: penalties.maintainability ?? 0,
-    },
-  };
-}
-
-export function computeVitalSigns(partial: Partial<VitalSigns>): VitalSigns {
-  return {
-    deadFilePct: partial.deadFilePct ?? 0,
-    deadExportPct: partial.deadExportPct ?? 0,
-    avgCyclomatic: partial.avgCyclomatic ?? 0,
-    p90Cyclomatic: partial.p90Cyclomatic ?? 0,
-    duplicationPct: partial.duplicationPct ?? 0,
-    hotspotCount: partial.hotspotCount ?? 0,
-    maintainabilityAvg: partial.maintainabilityAvg ?? 100,
-    unusedDepCount: partial.unusedDepCount ?? 0,
-    circularDepCount: partial.circularDepCount ?? 0,
-    counts: partial.counts ?? { unusedFiles: 0, unusedExports: 0, unusedTypes: 0, privateTypeLeaks: 0, unusedDependencies: 0, unresolvedImports: 0, circularDependencies: 0, boundaryViolations: 0 },
-    unitSizeProfile: partial.unitSizeProfile ?? { tiny: 0, small: 0, medium: 0, large: 0, huge: 0 },
-    couplingHighPct: partial.couplingHighPct ?? 0,
-  };
-}
-
-export function formatVitalSigns(vs: VitalSigns): string[] {
-  return [
-    `Dead files:        ${vs.counts.unusedFiles} (${vs.deadFilePct.toFixed(1)}%)`,
-    `Dead exports:      ${vs.counts.unusedExports} (${vs.deadExportPct.toFixed(1)}%)`,
-    `Avg cyclomatic:    ${vs.avgCyclomatic.toFixed(1)} (p90: ${vs.p90Cyclomatic.toFixed(1)})`,
-    `Duplication:       ${vs.duplicationPct.toFixed(1)}%`,
-    `Hotspots:          ${vs.hotspotCount}`,
-    `Maintainability:   ${vs.maintainabilityAvg.toFixed(1)}/100`,
-    `Unused deps:       ${vs.unusedDepCount}`,
-    `Circular deps:     ${vs.circularDepCount}`,
-    `High coupling:     ${vs.couplingHighPct.toFixed(1)}%`,
-  ];
-}

package/src/health/health-report.ts

@@ -1,81 +0,0 @@
-// Top-level container that bundles every health-pipeline output into a
-// single serializable object for LSP, CI, and dashboard consumers.
-
-export interface HealthReportSummary {
-  healthScore: number;
-  healthGrade: 'A' | 'B' | 'C' | 'D' | 'F';
-  totalFiles: number;
-  totalLoc: number;
-  issueCount: number;
-  coverageModel: string;
-  generatedAt: string;
-}
-
-export interface HealthReport {
-  summary: HealthReportSummary;
-
-  // Core analysis outputs (all optional — skipped-when-absent for partial runs)
-  findings?: unknown[];
-  fileScores?: unknown[];
-  coverageGaps?: unknown;
-  hotspots?: unknown[];
-  hotspotSummary?: unknown;
-  runtimeCoverage?: unknown;
-  largeFunctions?: unknown[];
-  targets?: unknown[];
-  targetThresholds?: unknown;
-  healthTrend?: unknown;
-  vitalSigns?: unknown;
-  distributionThresholds?: unknown;
-  analysisCounts?: unknown;
-  timings?: unknown;
-}
-
-export function createHealthReport(
-  summary: HealthReportSummary,
-  partials: Omit<HealthReport, 'summary'> = {},
-): HealthReport {
-  const report: HealthReport = { summary };
-  for (const [key, value] of Object.entries(partials) as [keyof Omit<HealthReport, 'summary'>, unknown][]) {
-    if (value !== undefined && value !== null) {
-      (report as unknown as Record<string, unknown>)[key] = value;
-    }
-  }
-  return report;
-}
-
-export function createHealthReportSummary(
-  healthScore: number,
-  totalFiles: number,
-  totalLoc: number,
-  coverageModel = 'none',
-): HealthReportSummary {
-  // Use canonical thresholds from health-report-types.ts (A≥90, B≥75, C≥60, D≥40)
-  const grade: HealthReportSummary['healthGrade'] =
-    healthScore >= 90 ? 'A' :
-    healthScore >= 75 ? 'B' :
-    healthScore >= 60 ? 'C' :
-    healthScore >= 40 ? 'D' : 'F';
-  return {
-    healthScore,
-    healthGrade: grade,
-    totalFiles,
-    totalLoc,
-    issueCount: 0,
-    coverageModel,
-    generatedAt: new Date().toISOString(),
-  };
-}
-
-export function formatHealthReportSummary(s: HealthReportSummary): string {
-  return [
-    `Health: ${s.healthGrade} (${s.healthScore.toFixed(1)}/100)`,
-    `Files: ${s.totalFiles}  LOC: ${s.totalLoc}`,
-    `Coverage model: ${s.coverageModel}`,
-    `Generated: ${s.generatedAt}`,
-  ].join('\n');
-}
-
-export function healthReportToJson(report: HealthReport): string {
-  return JSON.stringify(report, null, 2);
-}

package/src/health/health-score.ts

@@ -1,65 +0,0 @@
-export const HOTSPOT_SCORE_THRESHOLD = 50;
-export const MI_DENSITY_MIN_LINES = 50;
-
-export type HealthGrade = 'A' | 'B' | 'C' | 'D' | 'F';
-
-export interface HealthScorePenalties {
-  deadCode: number;
-  duplication: number;
-  complexityHigh: number;
-  complexityCritical: number;
-  crapHigh: number;
-  crapCritical: number;
-  hotspotDensity: number;
-  couplingConcentration: number;
-  busFactor: number;
-  largeFunctions: number;
-  unusedDeps: number;
-}
-
-export interface HealthScore {
-  value: number;           // 0–100
-  grade: HealthGrade;
-  penalties: HealthScorePenalties;
-}
-
-export interface VitalSignsInput {
-  deadCodePct: number;          // 0–100
-  duplicationPct: number;       // 0–100
-  complexityHighPct: number;    // 0–100
-  complexityCriticalPct: number;
-  crapHighPct: number;
-  crapCriticalPct: number;
-  hotspotDensity: number;       // 0–100 normalised hotspot score
-  couplingHighPct: number;
-  busFactorRisk: number;        // 0–1 (1 = bus factor of 1)
-  largeFunctionsPct: number;
-  unusedDepCount: number;
-}
-
-export function computeHealthScore(vs: VitalSignsInput, totalFiles: number): HealthScore {
-  const p: HealthScorePenalties = {
-    deadCode:             Math.min(15, vs.deadCodePct * 0.15),
-    duplication:          Math.min(15, vs.duplicationPct * 0.15),
-    complexityHigh:       Math.min(10, vs.complexityHighPct * 0.10),
-    complexityCritical:   Math.min(10, vs.complexityCriticalPct * 0.20),
-    crapHigh:             Math.min(10, vs.crapHighPct * 0.10),
-    crapCritical:         Math.min(10, vs.crapCriticalPct * 0.20),
-    hotspotDensity:       Math.min(10, vs.hotspotDensity * 0.10),
-    couplingConcentration:Math.min(5,  vs.couplingHighPct * 0.05),
-    busFactor:            Math.min(10, vs.busFactorRisk * 10),
-    largeFunctions:       Math.min(5,  vs.largeFunctionsPct * 0.10),
-    unusedDeps:           Math.min(5,  Math.min(vs.unusedDepCount, 10) * 0.5),
-  };
-  const total = Object.values(p).reduce((a, b) => a + b, 0);
-  const value = Math.max(0, Math.round(100 - total));
-  return { value, grade: letterGradeFromScore(value), penalties: p };
-}
-
-export function letterGradeFromScore(score: number): HealthGrade {
-  if (score >= 90) return 'A';
-  if (score >= 75) return 'B';
-  if (score >= 60) return 'C';
-  if (score >= 40) return 'D';
-  return 'F';
-}

package/src/health/hotspot-utils.ts

@@ -1,55 +0,0 @@
-export function isTestPath(filePath: string): boolean {
-  const normalized = filePath.replace(/\\/g, '/');
-  return (
-    normalized.includes('/__tests__/') ||
-    normalized.includes('/__mocks__/') ||
-    normalized.includes('/test/') ||
-    normalized.includes('/tests/') ||
-    normalized.includes('/e2e/') ||
-    normalized.includes('.test.') ||
-    normalized.includes('.spec.')
-  );
-}
-
-export interface NormalizationMaxima {
-  maxWeightedCommits: number;
-  maxComplexityDensity: number;
-}
-
-export function computeNormalizationMaxima(
-  files: Array<{ weightedCommits: number; complexityDensity: number }>,
-  percentile = 0.95,
-): NormalizationMaxima {
-  if (files.length < 2) {
-    const maxWeightedCommits = files.length === 1 ? files[0].weightedCommits : 0;
-    const maxComplexityDensity = files.length === 1 ? files[0].complexityDensity : 0;
-    return { maxWeightedCommits, maxComplexityDensity };
-  }
-
-  const sortedWeighted = [...files.map(f => f.weightedCommits)].sort((a, b) => a - b);
-  const sortedDensity = [...files.map(f => f.complexityDensity)].sort((a, b) => a - b);
-
-  const idx = Math.min(
-    Math.ceil(percentile * files.length) - 1,
-    files.length - 1,
-  );
-
-  return {
-    maxWeightedCommits: sortedWeighted[idx],
-    maxComplexityDensity: sortedDensity[idx],
-  };
-}
-
-export function normalizeHotspotScore(
-  rawChurn: number,
-  rawComplexity: number,
-  maxima: NormalizationMaxima,
-): number {
-  const normChurn = maxima.maxWeightedCommits > 0
-    ? rawChurn / maxima.maxWeightedCommits
-    : 0;
-  const normComplexity = maxima.maxComplexityDensity > 0
-    ? rawComplexity / maxima.maxComplexityDensity
-    : 0;
-  return Math.round((normChurn * 0.6 + normComplexity * 0.4) * 100 * 10) / 10;
-}

package/src/health/hotspots.ts

@@ -1,104 +0,0 @@
-import type { ChurnResult, FileChurn } from '../analysis/churn.js';
-
-export interface HotspotEntry {
-  path: string;
-  score: number;
-  weightedCommits: number;
-  complexityDensity: number;
-  rank: number;
-}
-
-export interface HotspotSummary {
-  count: number;
-  topScore: number;
-  meanScore: number;
-}
-
-const TEST_PATH_PATTERNS = [
-  '/__tests__/',
-  '.test.',
-  '.spec.',
-  '_test.',
-  '_spec.',
-  '/test/',
-  '/tests/',
-  '/spec/',
-  '/specs/',
-];
-
-export function isTestPath(path: string): boolean {
-  for (const pattern of TEST_PATH_PATTERNS) {
-    if (path.includes(pattern)) return true;
-  }
-  return false;
-}
-
-export function normalizeValue(value: number, max: number): number {
-  return max > 0 ? value / max : 0;
-}
-
-export function computeHotspotScore(
-  weightedCommits: number,
-  maxWeighted: number,
-  density: number,
-  maxDensity: number,
-): number {
-  return normalizeValue(weightedCommits, maxWeighted) * normalizeValue(density, maxDensity) * 100;
-}
-
-export function computeHotspots(
-  churnResult: ChurnResult,
-  complexityMap: Map<string, number>,
-  minCommits = 3,
-): { entries: HotspotEntry[]; summary: HotspotSummary } {
-  // Filter qualifying files
-  const qualifying = churnResult.files.filter(
-    (f) => !isTestPath(f.path) && f.totalCommits >= minCommits,
-  );
-
-  if (qualifying.length === 0) {
-    return {
-      entries: [],
-      summary: { count: 0, topScore: 0, meanScore: 0 },
-    };
-  }
-
-  // Compute normalization maxima from qualifying files only
-  let maxWeighted = 0;
-  let maxDensity = 0;
-
-  for (const f of qualifying) {
-    if (f.weightedCommits > maxWeighted) maxWeighted = f.weightedCommits;
-    const density = complexityMap.get(f.path) ?? 0;
-    if (density > maxDensity) maxDensity = density;
-  }
-
-  // Score each qualifying file
-  const scored = qualifying.map((f) => {
-    const density = complexityMap.get(f.path) ?? 0;
-    const score = computeHotspotScore(f.weightedCommits, maxWeighted, density, maxDensity);
-    return { f, score, density };
-  });
-
-  // Sort descending by score
-  scored.sort((a, b) => b.score - a.score);
-
-  // Build entries with 1-based rank
-  const entries: HotspotEntry[] = scored.map((item, idx) => ({
-    path: item.f.path,
-    score: item.score,
-    weightedCommits: item.f.weightedCommits,
-    complexityDensity: item.density,
-    rank: idx + 1,
-  }));
-
-  // Compute summary
-  const count = entries.length;
-  const topScore = entries[0]?.score ?? 0;
-  const meanScore = count > 0 ? entries.reduce((s, e) => s + e.score, 0) / count : 0;
-
-  return {
-    entries,
-    summary: { count, topScore, meanScore },
-  };
-}

package/src/health/large-functions.ts

@@ -1,34 +0,0 @@
-export const LARGE_FUNCTION_LOC_THRESHOLD = 60;
-export const LARGE_FUNCTION_REPORT_THRESHOLD_PCT = 0.03;
-
-export interface LargeFunctionEntry {
-  path: string;
-  functionName: string;
-  lineCount: number;
-  startLine: number;
-}
-
-export function shouldReportLargeFunctions(
-  veryHighCount: number,
-  totalFunctions: number
-): boolean {
-  if (totalFunctions <= 0) {
-    return false;
-  }
-  return veryHighCount / totalFunctions >= LARGE_FUNCTION_REPORT_THRESHOLD_PCT;
-}
-
-export function detectLargeFunctions(
-  functions: Array<{ path: string; name: string; loc: number; startLine: number }>,
-  threshold = LARGE_FUNCTION_LOC_THRESHOLD
-): LargeFunctionEntry[] {
-  return functions
-    .filter((f) => f.loc >= threshold)
-    .sort((a, b) => b.loc - a.loc)
-    .map((f) => ({
-      path: f.path,
-      functionName: f.name,
-      lineCount: f.loc,
-      startLine: f.startLine,
-    }));
-}

package/src/health/ownership-metrics.ts

@@ -1,61 +0,0 @@
-export type ContributorIdentifierFormat = 'raw' | 'handle' | 'hash';
-
-export interface ContributorEntry {
-  identifier: string;
-  format: ContributorIdentifierFormat;
-  share: number;
-  staleDays: number;
-  commits: number;
-}
-
-export interface OwnershipMetrics {
-  busFactor: number;
-  contributorCount: number;
-  topContributor: ContributorEntry;
-  recentContributors: ContributorEntry[];
-  suggestedReviewers: ContributorEntry[];
-  declaredOwner?: string;
-  unowned?: boolean;
-  drift: boolean;
-  driftReason?: string;
-}
-
-export interface HotspotSummary {
-  since: string;
-  minCommits: number;
-  filesAnalyzed: number;
-  filesExcluded: number;
-  shallowClone: boolean;
-}
-
-export function computeBusFactor(contributors: ContributorEntry[]): number {
-  if (contributors.length === 0) return 0;
-  const sorted = [...contributors].sort((a, b) => b.share - a.share);
-  let cumulative = 0;
-  for (let i = 0; i < sorted.length; i++) {
-    cumulative += sorted[i].share;
-    if (cumulative >= 0.5) return i + 1;
-  }
-  return sorted.length;
-}
-
-export function filterSuggestedReviewers(
-  contributors: ContributorEntry[],
-  topContributor: ContributorEntry,
-  maxStaleDays = 90,
-): ContributorEntry[] {
-  return contributors
-    .filter(c => c.identifier !== topContributor.identifier && c.staleDays <= maxStaleDays)
-    .slice(0, 3);
-}
-
-export function formatOwnershipMetrics(m: OwnershipMetrics): string {
-  const lines: string[] = [
-    `Bus factor: ${m.busFactor}  (${m.contributorCount} contributor${m.contributorCount !== 1 ? 's' : ''})`,
-    `Top: ${m.topContributor.identifier} (${(m.topContributor.share * 100).toFixed(1)}%)`,
-  ];
-  if (m.declaredOwner) lines.push(`Owner: ${m.declaredOwner}`);
-  if (m.unowned) lines.push('(unowned — no CODEOWNERS rule matched)');
-  if (m.drift) lines.push(`Drift: ${m.driftReason ?? 'unknown reason'}`);
-  return lines.join('\n');
-}