Add max CCN

Author: Hugo-ter-Doest

prisma/schema.prisma

@@ -42,6 +42,7 @@ model ScoringConfig {
   id               String         @id @default(uuid())
   criterionWeights Json
   complexityThreshold Int          @default(15)
+  complexityMaxCcnThreshold Int    @default(30)
   createdAt        DateTime       @default(now())
   updatedAt        DateTime @updatedAt
   analyses         RepoAnalysis[]

src/app/admin/page.tsx

@@ -1,6 +1,7 @@
 import Link from "next/link";
 import AdminWeightsForm from "@/components/AdminWeightsForm";
 import {
+  DEFAULT_COMPLEXITY_MAX_CCN_THRESHOLD,
   DEFAULT_COMPLEXITY_THRESHOLD,
   DEFAULT_CRITERION_CONFIG_BY_CHECK_ID,
   getScoringConfig,
@@ -52,6 +53,12 @@ export default async function AdminPage() {
         defaultWeights={defaultWeights}
         initialComplexityThreshold={scoringConfig.complexityThreshold}
         defaultComplexityThreshold={DEFAULT_COMPLEXITY_THRESHOLD}
+        initialComplexityMaxCcnThreshold={
+          scoringConfig.complexityMaxCcnThreshold
+        }
+        defaultComplexityMaxCcnThreshold={
+          DEFAULT_COMPLEXITY_MAX_CCN_THRESHOLD
+        }
       />
     </div>
   );

src/app/api/admin/scoring/route.ts

@@ -1,5 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import {
+  DEFAULT_COMPLEXITY_MAX_CCN_THRESHOLD,
   DEFAULT_COMPLEXITY_THRESHOLD,
   DEFAULT_CRITERION_CONFIG_BY_CHECK_ID,
   getScoringConfig,
@@ -30,6 +31,16 @@ function extractComplexityThresholdFromPayload(payload: unknown): number | undef
   return value;
 }
 
+function extractComplexityMaxCcnThresholdFromPayload(
+  payload: unknown
+): number | undefined {
+  if (!payload || typeof payload !== "object") return undefined;
+  const raw = payload as Record<string, unknown>;
+  const value = raw.complexityMaxCcnThreshold;
+  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+  return value;
+}
+
 export async function GET() {
   try {
     const scoringConfig = await getScoringConfig();
@@ -42,13 +53,15 @@ export async function GET() {
         ])
       ),
       complexityThreshold: scoringConfig.complexityThreshold,
+      complexityMaxCcnThreshold: scoringConfig.complexityMaxCcnThreshold,
       defaultCriterionWeights: Object.fromEntries(
         Object.entries(DEFAULT_CRITERION_CONFIG_BY_CHECK_ID).map(([checkId, config]) => [
           checkId,
           config.weight,
         ])
       ),
       defaultComplexityThreshold: DEFAULT_COMPLEXITY_THRESHOLD,
+      defaultComplexityMaxCcnThreshold: DEFAULT_COMPLEXITY_MAX_CCN_THRESHOLD,
     });
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : "Unexpected error.";
@@ -61,18 +74,26 @@ export async function POST(req: NextRequest) {
     const body = await req.json();
     const reset = body?.reset === true;
     const incomingThreshold = extractComplexityThresholdFromPayload(body);
+    const incomingMaxThreshold =
+      extractComplexityMaxCcnThresholdFromPayload(body);
 
     const activeConfig = reset
-      ? await saveCriterionWeights({}, DEFAULT_COMPLEXITY_THRESHOLD)
+      ? await saveCriterionWeights(
+          {},
+          DEFAULT_COMPLEXITY_THRESHOLD,
+          DEFAULT_COMPLEXITY_MAX_CCN_THRESHOLD
+        )
       : await saveCriterionWeights(
           extractWeightsFromPayload(body?.criterionWeights),
-          incomingThreshold
+          incomingThreshold,
+          incomingMaxThreshold
         );
 
     return NextResponse.json({
       ok: true,
       scoringConfigId: activeConfig.id,
       complexityThreshold: activeConfig.config.complexityThreshold,
+      complexityMaxCcnThreshold: activeConfig.config.complexityMaxCcnThreshold,
       criterionWeights: Object.fromEntries(
         Object.entries(activeConfig.config.criterionConfigByCheckId).map(([checkId, config]) => [
           checkId,

src/components/AdminWeightsForm.tsx

@@ -141,18 +141,24 @@ interface AdminWeightsFormProps {
   defaultWeights: Record<string, number>;
   initialComplexityThreshold: number;
   defaultComplexityThreshold: number;
+  initialComplexityMaxCcnThreshold: number;
+  defaultComplexityMaxCcnThreshold: number;
 }
 
 export default function AdminWeightsForm({
   initialWeights,
   defaultWeights,
   initialComplexityThreshold,
   defaultComplexityThreshold,
+  initialComplexityMaxCcnThreshold,
+  defaultComplexityMaxCcnThreshold,
 }: AdminWeightsFormProps) {
   const [weights, setWeights] = useState<Record<string, number>>(initialWeights);
   const [complexityThreshold, setComplexityThreshold] = useState<number>(
     initialComplexityThreshold
   );
+  const [complexityMaxCcnThreshold, setComplexityMaxCcnThreshold] =
+    useState<number>(initialComplexityMaxCcnThreshold);
   const [saving, setSaving] = useState(false);
   const [message, setMessage] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
@@ -164,8 +170,19 @@ export default function AdminWeightsForm({
       return current !== initial;
     });
 
-    return weightChanged || complexityThreshold !== initialComplexityThreshold;
-  }, [weights, initialWeights, complexityThreshold, initialComplexityThreshold]);
+    return (
+      weightChanged ||
+      complexityThreshold !== initialComplexityThreshold ||
+      complexityMaxCcnThreshold !== initialComplexityMaxCcnThreshold
+    );
+  }, [
+    weights,
+    initialWeights,
+    complexityThreshold,
+    initialComplexityThreshold,
+    complexityMaxCcnThreshold,
+    initialComplexityMaxCcnThreshold,
+  ]);
 
   async function save() {
     setSaving(true);
@@ -178,6 +195,7 @@ export default function AdminWeightsForm({
         body: JSON.stringify({
           criterionWeights: weights,
           complexityThreshold,
+          complexityMaxCcnThreshold,
         }),
       });
       const data = await res.json();
@@ -191,6 +209,9 @@ export default function AdminWeightsForm({
         if (typeof data?.complexityThreshold === "number") {
           setComplexityThreshold(data.complexityThreshold);
         }
+        if (typeof data?.complexityMaxCcnThreshold === "number") {
+          setComplexityMaxCcnThreshold(data.complexityMaxCcnThreshold);
+        }
       }
     } catch {
       setError("Network error while saving weights.");
@@ -202,6 +223,7 @@ export default function AdminWeightsForm({
   function resetToDefaults() {
     setWeights(defaultWeights);
     setComplexityThreshold(defaultComplexityThreshold);
+    setComplexityMaxCcnThreshold(defaultComplexityMaxCcnThreshold);
     setMessage(null);
     setError(null);
   }
@@ -242,6 +264,27 @@ export default function AdminWeightsForm({
             className="w-24 rounded-md border border-gray-300 px-2 py-1 text-sm"
           />
         </div>
+        <div className="flex items-center gap-3">
+          <label htmlFor="complexity-max-ccn-threshold" className="text-sm font-medium text-gray-700">
+            Lizard threshold (Max CCN)
+          </label>
+          <input
+            id="complexity-max-ccn-threshold"
+            type="number"
+            min={1}
+            max={200}
+            step={1}
+            value={complexityMaxCcnThreshold}
+            onChange={(event) => {
+              const next = Number(event.target.value);
+              if (!Number.isFinite(next)) return;
+              setComplexityMaxCcnThreshold(
+                Math.max(1, Math.min(200, Math.round(next)))
+              );
+            }}
+            className="w-24 rounded-md border border-gray-300 px-2 py-1 text-sm"
+          />
+        </div>
       </div>
 
       <div className="space-y-4">

src/lib/checkers/complexity.ts

@@ -70,7 +70,11 @@ function extractThresholdBreaches(output: string): string[] {
     .slice(0, 10);
 }
 
-function extractSummary(output: string): { averageCcn: number; functionCount: number } | null {
+function extractSummary(output: string): {
+  averageCcn: number;
+  maxCcn: number;
+  functionCount: number;
+} | null {
   const lines = output
     .split(/\r?\n/)
     .map((line) => line.trim())
@@ -89,7 +93,7 @@ function extractSummary(output: string): { averageCcn: number; functionCount: nu
       const avgCcn = Number(numericParts[2]);
       const functionCount = Number(numericParts[4]);
       if (Number.isFinite(avgCcn) && Number.isFinite(functionCount)) {
-        return { averageCcn: avgCcn, functionCount };
+        return { averageCcn: avgCcn, maxCcn: avgCcn, functionCount };
       }
     }
   }
@@ -99,6 +103,7 @@ function extractSummary(output: string): { averageCcn: number; functionCount: nu
 
 function extractAverageFromFunctionRows(output: string): {
   averageCcn: number;
+  maxCcn: number;
   functionCount: number;
 } | null {
   const lines = output.split(/\r?\n/);
@@ -125,16 +130,19 @@ function extractAverageFromFunctionRows(output: string): {
   }
 
   const total = ccnValues.reduce((sum, value) => sum + value, 0);
+  const maxCcn = Math.max(...ccnValues);
   return {
     averageCcn: total / ccnValues.length,
+    maxCcn,
     functionCount: ccnValues.length,
   };
 }
 
 export async function checkComplexity(
   owner: string,
   repo: string,
-  threshold: number
+  averageThreshold: number,
+  maxCcnThreshold: number
 ): Promise<CheckResult> {
   const lizard = await detectLizardCommand();
 
@@ -183,7 +191,8 @@ export async function checkComplexity(
       };
     }
 
-    const thresholdText = String(Math.max(1, Math.round(threshold)));
+    const averageThresholdText = String(Math.max(1, Math.round(averageThreshold)));
+    const maxCcnThresholdText = String(Math.max(1, Math.round(maxCcnThreshold)));
     const args = [
       ...lizard.argsPrefix,
       "-x",
@@ -256,46 +265,62 @@ export async function checkComplexity(
     }
 
     const averageCcn = summary.averageCcn;
+    const maxCcn = summary.maxCcn;
+
+    const passesAverage = averageCcn <= Number(averageThresholdText);
+    const passesMax = maxCcn <= Number(maxCcnThresholdText);
 
-    if (averageCcn <= Number(thresholdText)) {
+    if (passesAverage && passesMax) {
       return {
         id: "complexity",
         title: "Cyclomatic complexity (Lizard)",
         description:
           "The repository should be analyzed with Lizard to track cyclomatic complexity across supported languages.",
         status: "pass",
         message:
-          `Lizard analysis executed successfully. Average cyclomatic complexity is ${averageCcn.toFixed(
+          `Lizard analysis executed successfully. AvgCCN ${averageCcn.toFixed(
             2
-          )}, within threshold ${thresholdText}.`,
+          )} <= ${averageThresholdText} and MaxCCN ${maxCcn.toFixed(
+            2
+          )} <= ${maxCcnThresholdText}.`,
         evidence: [
           `Analyzer: ${lizard.command} ${lizard.argsPrefix.join(" ")}`.trim(),
           ...(analysis.code !== 0
             ? [`Lizard returned non-zero exit code ${analysis.code}, but summary metrics were parsed.`]
             : []),
-          `Average CCN: ${averageCcn.toFixed(2)} (threshold: ${thresholdText})`,
+          `Average CCN: ${averageCcn.toFixed(2)} (threshold: ${averageThresholdText})`,
+          `Max CCN: ${maxCcn.toFixed(2)} (threshold: ${maxCcnThresholdText})`,
           ...evidence,
         ].slice(0, 10),
         referenceUrl: "https://github.com/terryyin/lizard",
       };
     }
 
+    const exceeded: string[] = [];
+    if (!passesAverage) {
+      exceeded.push(
+        `AvgCCN ${averageCcn.toFixed(2)} > ${averageThresholdText}`
+      );
+    }
+    if (!passesMax) {
+      exceeded.push(`MaxCCN ${maxCcn.toFixed(2)} > ${maxCcnThresholdText}`);
+    }
+
     return {
       id: "complexity",
       title: "Cyclomatic complexity (Lizard)",
       description:
         "The repository should be analyzed with Lizard to track cyclomatic complexity across supported languages.",
       status: "fail",
       message:
-        `Lizard analysis ran. Average cyclomatic complexity is ${averageCcn.toFixed(
-          2
-        )}, above threshold ${thresholdText}.`,
+        `Lizard analysis ran. Threshold exceeded: ${exceeded.join("; ")}.`,
       evidence: [
         `Analyzer: ${lizard.command} ${lizard.argsPrefix.join(" ")}`.trim(),
         ...(analysis.code !== 0
           ? [`Lizard returned non-zero exit code ${analysis.code}, but summary metrics were parsed.`]
           : []),
-        `Average CCN: ${averageCcn.toFixed(2)} (threshold: ${thresholdText})`,
+        `Average CCN: ${averageCcn.toFixed(2)} (threshold: ${averageThresholdText})`,
+        `Max CCN: ${maxCcn.toFixed(2)} (threshold: ${maxCcnThresholdText})`,
         ...(evidence.length > 0 ? evidence : ["See lizard output for details."]),
       ].slice(0, 10),
       referenceUrl: "https://github.com/terryyin/lizard",