claude-crap 0.4.6 → 0.4.8

package/plugin/hooks/lib/quality-gate.mjs

@@ -150,6 +150,9 @@ const LOC_WALK_SKIP_DIRS = new Set([
   ".git",
   // Build outputs
   "dist", "build", "bundle", "out", "target", "coverage",
+  // Test coverage report bundles (ReportGenerator, Istanbul, coverage.py, dotnet test)
+  "coverage-report", "CoverageReport", "coveragereport",
+  "TestResults", "cobertura", "lcov-report", "htmlcov",
   // Framework build outputs
   ".next", ".nuxt", ".output", ".vercel", ".svelte-kit",
   ".astro", ".angular", ".turbo", ".parcel-cache", ".expo",

package/src/dashboard/file-detail.ts

@@ -58,6 +58,12 @@ export interface FileDetailSummary {
 /** Full response payload for the file detail endpoint. */
 export interface FileDetailResponse {
   readonly filePath: string;
+  /**
+   * Absolute path on the host filesystem, already resolved through the
+   * workspace-traversal guard. The UI uses this to build editor
+   * deep-links (e.g. `vscode://file/{absolutePath}:{line}`).
+   */
+  readonly absolutePath: string;
   readonly language: SupportedLanguage | null;
   readonly physicalLoc: number;
   readonly logicalLoc: number;
@@ -175,6 +181,7 @@ export async function buildFileDetail(
 
   return {
     filePath: relativePath,
+    absolutePath,
     language,
     physicalLoc,
     logicalLoc,

package/src/dashboard/public/index.html

@@ -317,6 +317,95 @@
         opacity: 0.7;
         margin-left: 12px;
       }
+      /* CC heat bar — ReportGenerator-style visual severity */
+      .heat-bar {
+        position: relative;
+        width: 140px;
+        height: 8px;
+        background: rgba(255, 255, 255, 0.06);
+        border-radius: 4px;
+        overflow: hidden;
+      }
+      .heat-bar-fill {
+        height: 100%;
+        border-radius: 4px;
+        transition: width 120ms ease-out;
+      }
+      .heat-bar-threshold {
+        position: absolute;
+        top: -2px;
+        bottom: -2px;
+        width: 1px;
+        background: rgba(255, 255, 255, 0.35);
+      }
+      /* CC chip — numeric value + % of threshold */
+      .cc-chip {
+        display: inline-flex;
+        align-items: baseline;
+        gap: 6px;
+        font-variant-numeric: tabular-nums;
+      }
+      .cc-chip .cc-value {
+        font-weight: 700;
+        font-size: 13px;
+      }
+      .cc-chip .cc-ratio {
+        font-size: 11px;
+        color: var(--muted);
+      }
+      /* Method name button — scrolls source view to fn start line */
+      .method-jump {
+        background: none;
+        border: none;
+        padding: 0;
+        font: inherit;
+        font-family: "SF Mono", "Fira Code", "Consolas", monospace;
+        font-size: 13px;
+        color: var(--accent);
+        cursor: pointer;
+      }
+      .method-jump:hover { text-decoration: underline; }
+      /* "Open in editor" icon link */
+      .editor-link {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        width: 24px;
+        height: 24px;
+        border-radius: 4px;
+        color: var(--muted);
+        text-decoration: none;
+        font-size: 13px;
+        transition: background 120ms, color 120ms;
+      }
+      .editor-link:hover {
+        background: rgba(62, 166, 255, 0.12);
+        color: var(--accent);
+        text-decoration: none;
+      }
+      /* "Show all / show fewer" toggle under the methods table */
+      .show-all-btn {
+        display: inline-block;
+        margin: 12px 0 0 0;
+        padding: 6px 12px;
+        background: transparent;
+        border: 1px solid var(--border);
+        border-radius: 6px;
+        color: var(--accent);
+        font-size: 12px;
+        cursor: pointer;
+      }
+      .show-all-btn:hover {
+        background: rgba(62, 166, 255, 0.08);
+      }
+      /* Line-flash animation when the user jumps to a source line */
+      .source-line.jump-target {
+        animation: jumpFlash 1.2s ease-out;
+      }
+      @keyframes jumpFlash {
+        0%   { background: rgba(62, 166, 255, 0.35); }
+        100% { background: transparent; }
+      }
     </style>
   </head>
   <body>
@@ -372,33 +461,74 @@
             </div>
           </div>
 
-          <!-- Methods table -->
-          <div v-if="fileDetail.functions.length" class="section-title">Methods</div>
+          <!-- Methods table — top-5 by CC with heat bar + jump + editor link -->
+          <div v-if="fileDetail.functions.length" class="section-title">
+            Methods
+            <span style="color: var(--muted); font-weight: 400; text-transform: none; letter-spacing: 0; margin-left: 8px;">
+              threshold CC {{ fileDetail.cyclomaticMax }}
+            </span>
+          </div>
           <div v-if="fileDetail.functions.length" class="card">
             <table>
               <thead>
                 <tr>
                   <th>Method</th>
                   <th style="text-align: right">Line</th>
-                  <th style="text-align: right">CC</th>
+                  <th style="width: 180px;">CC</th>
                   <th style="text-align: right">Lines</th>
                   <th>Status</th>
+                  <th style="width: 32px;"></th>
                 </tr>
               </thead>
               <tbody>
-                <tr v-for="fn in sortedFunctions" :key="fn.startLine">
-                  <td><code>{{ fn.name }}</code></td>
+                <tr v-for="fn in visibleFunctions" :key="fn.startLine">
+                  <td>
+                    <button
+                      class="method-jump"
+                      @click="jumpToLine(fn.startLine)"
+                      :title="'Jump to line ' + fn.startLine"
+                    >{{ fn.name }}</button>
+                  </td>
                   <td style="text-align: right; font-variant-numeric: tabular-nums;">{{ fn.startLine }}</td>
-                  <td style="text-align: right; font-variant-numeric: tabular-nums;">{{ fn.cyclomaticComplexity }}</td>
+                  <td>
+                    <div class="cc-chip">
+                      <div class="heat-bar" :title="ccTooltip(fn)">
+                        <div
+                          class="heat-bar-fill"
+                          :style="heatBarStyle(fn)"
+                        ></div>
+                        <div
+                          class="heat-bar-threshold"
+                          :style="{ left: thresholdMarker() + '%' }"
+                        ></div>
+                      </div>
+                      <span class="cc-value" :style="{ color: ccColor(fn) }">{{ fn.cyclomaticComplexity }}</span>
+                      <span class="cc-ratio">{{ ccRatio(fn) }}%</span>
+                    </div>
+                  </td>
                   <td style="text-align: right; font-variant-numeric: tabular-nums;">{{ fn.lineCount }}</td>
                   <td>
                     <span v-if="fn.cyclomaticComplexity >= fileDetail.cyclomaticMax * 2" class="pill pill-error">error</span>
                     <span v-else-if="fn.cyclomaticComplexity > fileDetail.cyclomaticMax" class="pill pill-warning">warning</span>
                     <span v-else class="pill pill-note">ok</span>
                   </td>
+                  <td>
+                    <a
+                      class="editor-link"
+                      :href="editorLink(fn)"
+                      :title="'Open ' + fileDetail.filePath + ':' + fn.startLine + ' in VS Code'"
+                    >&#x2197;</a>
+                  </td>
                 </tr>
               </tbody>
             </table>
+            <button
+              v-if="fileDetail.functions.length > topMethodsLimit"
+              class="show-all-btn"
+              @click="toggleShowAllMethods()"
+            >
+              {{ showAllMethods ? 'Show top ' + topMethodsLimit : 'Show all ' + fileDetail.functions.length + ' methods' }}
+            </button>
           </div>
 
           <!-- Findings table -->
@@ -622,11 +752,87 @@
           });
 
           // ── File detail computed ──
+          const topMethodsLimit = 5;
+          const showAllMethods = ref(false);
+
           const sortedFunctions = computed(() => {
             if (!fileDetail.value) return [];
             return [...fileDetail.value.functions].sort((a, b) => b.cyclomaticComplexity - a.cyclomaticComplexity);
           });
 
+          const visibleFunctions = computed(() => {
+            if (showAllMethods.value) return sortedFunctions.value;
+            return sortedFunctions.value.slice(0, topMethodsLimit);
+          });
+
+          function toggleShowAllMethods() {
+            showAllMethods.value = !showAllMethods.value;
+          }
+
+          // ── CC heat-bar helpers ──
+          // Fill width is clamped at 3× threshold so a CC of 80 with
+          // threshold 15 still produces a visually meaningful bar rather
+          // than overflowing. The threshold marker sits at the "1.0×"
+          // position (i.e. threshold/3threshold = 33%).
+          function ccRatio(fn) {
+            const max = fileDetail.value?.cyclomaticMax || 1;
+            return Math.round((fn.cyclomaticComplexity / max) * 100);
+          }
+
+          function heatBarStyle(fn) {
+            const max = fileDetail.value?.cyclomaticMax || 1;
+            const cap = max * 3;
+            const pct = Math.min(100, (fn.cyclomaticComplexity / cap) * 100);
+            return { width: pct + "%", background: ccColor(fn) };
+          }
+
+          function thresholdMarker() {
+            // threshold sits at 1/3 of the bar (since we cap at 3× threshold)
+            return 33.33;
+          }
+
+          function ccColor(fn) {
+            const max = fileDetail.value?.cyclomaticMax || 1;
+            const r = fn.cyclomaticComplexity / max;
+            if (r >= 2) return "var(--rating-E)"; // red — error (≥ 2×)
+            if (r > 1) return "var(--rating-C)";  // yellow — warning
+            if (r > 0.66) return "var(--rating-B)"; // yellow-green — near threshold
+            return "var(--rating-A)";              // green — healthy
+          }
+
+          function ccTooltip(fn) {
+            const max = fileDetail.value?.cyclomaticMax || 1;
+            return (
+              "CC " + fn.cyclomaticComplexity +
+              " / threshold " + max +
+              " (" + ccRatio(fn) + "% of threshold)"
+            );
+          }
+
+          // ── Editor deep-link + jump-to-line ──
+          // vscode:// handler accepts absolute paths. The `absolutePath`
+          // field is resolved server-side through the workspace-traversal
+          // guard, so this is safe to paste into an href.
+          function editorLink(fn) {
+            const abs = fileDetail.value?.absolutePath;
+            if (!abs) return "#";
+            return "vscode://file" + abs + ":" + fn.startLine + ":1";
+          }
+
+          function jumpToLine(lineNum) {
+            // Source lines are keyed by 0-based index, so line N lives at
+            // child index N-1 of `.source-view`.
+            const view = document.querySelector(".source-view");
+            if (!view) return;
+            const row = view.children[lineNum - 1];
+            if (!row) return;
+            row.scrollIntoView({ behavior: "smooth", block: "center" });
+            row.classList.remove("jump-target");
+            // force reflow so the animation restarts on repeat clicks
+            void row.offsetWidth;
+            row.classList.add("jump-target");
+          }
+
           const sortedFindings = computed(() => {
             if (!fileDetail.value) return [];
             return [...fileDetail.value.findings].sort((a, b) => a.startLine - b.startLine);
@@ -777,7 +983,10 @@
             currentView, selectedFile, fileDetail,
             score, complexity, loading, error,
             toolEntries, fileEntries, formatTimestamp,
-            sortedFunctions, sortedFindings,
+            sortedFunctions, sortedFindings, visibleFunctions,
+            showAllMethods, toggleShowAllMethods, topMethodsLimit,
+            ccRatio, ccColor, ccTooltip, heatBarStyle, thresholdMarker,
+            editorLink, jumpToLine,
             navigateToFile, goBack,
             lineFindings, lineClass, gutterClass, lineFnLabel,
           };

package/src/dashboard/server.ts

@@ -72,9 +72,15 @@ export interface StartDashboardOptions {
 /**
  * Handle returned by {@link startDashboard}. Use `url` to build the
  * link the user clicks; call `close()` during shutdown.
+ *
+ * `adopted === true` means another claude-crap process already owned
+ * the dashboard port when we booted, and we are piggy-backing on its
+ * HTTP server. Adopted handles have a no-op `close()` because tearing
+ * down the Fastify instance would strand the other MCP servers.
  */
 export interface DashboardHandle {
   readonly url: string;
+  readonly adopted: boolean;
   close(): Promise<void>;
 }
 
@@ -87,6 +93,28 @@ export interface DashboardHandle {
  */
 export async function startDashboard(options: StartDashboardOptions): Promise<DashboardHandle> {
   const { config, sarifStore, workspaceStatsProvider, logger } = options;
+  const pidFilePath = resolvePidFilePath(config);
+
+  // Adopt-don't-steal: if a prior MCP server is already serving the
+  // dashboard on this port AND is healthy, piggy-back on it instead of
+  // killing it. This is what keeps N concurrent launchers from
+  // thrashing the port in an endless SIGTERM loop.
+  const adoption = await tryAdoptExisting(pidFilePath, config.dashboardPort, logger);
+  if (adoption) {
+    logger.info(
+      { url: adoption.url, ownerPid: adoption.pid, port: config.dashboardPort },
+      "adopted existing claude-crap dashboard",
+    );
+    return {
+      url: adoption.url,
+      adopted: true,
+      async close() {
+        // No-op: we never bound a socket of our own, so there is
+        // nothing to release. Removing the pidfile here would make the
+        // owner's `close()` race with our cleanup.
+      },
+    };
+  }
 
   // Resolve the public/ directory. After `npm run build` the compiled
   // server lives in `dist/dashboard/server.js`, but we keep the static
@@ -173,22 +201,41 @@ export async function startDashboard(options: StartDashboardOptions): Promise<Da
     return reply.sendFile("index.html");
   });
 
-  // Kill any stale dashboard from a previous session so we always
-  // bind to the configured port. This mirrors claude-mem's PID file
-  // pattern: write a PID file when alive, check + kill on next boot.
-  const pidFilePath = resolvePidFilePath(config);
-  await killStaleDashboard(pidFilePath, config.dashboardPort, logger);
-
-  await fastify.listen({ port: config.dashboardPort, host: "127.0.0.1" });
+  // The pidfile was either missing, stale, or pointed at a zombie —
+  // `tryAdoptExisting` has already cleaned it up. Try to bind. If we
+  // lose a race against another launcher that bound between our probe
+  // and our listen, fall back to adoption instead of failing.
+  try {
+    await fastify.listen({ port: config.dashboardPort, host: "127.0.0.1" });
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "EADDRINUSE") {
+      await fastify.close().catch(() => { /* best effort */ });
+      const raceAdoption = await tryAdoptExisting(pidFilePath, config.dashboardPort, logger);
+      if (raceAdoption) {
+        logger.info(
+          { url: raceAdoption.url, ownerPid: raceAdoption.pid, port: config.dashboardPort },
+          "dashboard bind lost race, adopted concurrent owner",
+        );
+        return {
+          url: raceAdoption.url,
+          adopted: true,
+          async close() { /* no-op — see adopted branch above */ },
+        };
+      }
+    }
+    throw err;
+  }
 
   const url = `http://127.0.0.1:${config.dashboardPort}`;
   logger.info({ url, publicRoot }, "claude-crap dashboard listening");
 
-  // Write PID file so the next session can find and kill us.
+  // Write PID file so sibling MCP servers can find us and adopt.
   writePidFile(pidFilePath, config.dashboardPort);
 
   return {
     url,
+    adopted: false,
     async close() {
       removePidFile(pidFilePath);
       await fastify.close();
@@ -310,71 +357,101 @@ function isPidAlive(pid: number): boolean {
 }
 
 /**
- * Read the PID file, kill any stale dashboard process, and free the
- * port so the current session can bind to it. This is the key
- * difference from the port-fallback approach: instead of drifting to
- * 5118, 5119, etc., we reclaim the configured port every time.
+ * Probe an existing dashboard and decide whether the current process
+ * can adopt it instead of binding its own Fastify server.
  *
- * @param pidFilePath  Absolute path to `dashboard.pid`.
- * @param port         The configured dashboard port.
- * @param logger       Pino logger for diagnostics.
+ * Returns `{ url, pid }` only when all four conditions hold:
+ *   1. A pidfile exists and parses as JSON.
+ *   2. The recorded PID is still alive (signal-0 probe).
+ *   3. The pidfile's recorded port matches the configured port.
+ *   4. A GET on `/api/health` responds within ~500ms.
+ *
+ * Returns `null` in every other case, but with a side-effect that makes
+ * the call-site's next step obvious:
+ *   - Missing / corrupt / dead-PID / port-mismatch  → pidfile is removed
+ *     so the caller can bind cleanly.
+ *   - Zombie (PID alive, port unresponsive)         → stale owner is
+ *     SIGKILL'd and the pidfile is removed. This is the one case where
+ *     we still have to kill something, because the socket belongs to a
+ *     process that is not talking HTTP anymore.
  */
-async function killStaleDashboard(
+async function tryAdoptExisting(
   pidFilePath: string,
   port: number,
   logger: Logger,
-): Promise<void> {
-  if (!existsSync(pidFilePath)) return;
+): Promise<{ url: string; pid: number } | null> {
+  if (!existsSync(pidFilePath)) return null;
 
   let stale: DashboardPidFile;
   try {
     stale = JSON.parse(readFileSync(pidFilePath, "utf8"));
   } catch {
-    // Corrupted PID file — remove it and move on.
+    logger.info({ pidFilePath }, "corrupt dashboard pidfile, removing");
     removePidFile(pidFilePath);
-    return;
+    return null;
   }
 
   if (!isPidAlive(stale.pid)) {
-    logger.info({ stalePid: stale.pid }, "stale dashboard PID file found (process dead), removing");
+    logger.info({ stalePid: stale.pid }, "stale dashboard pidfile (process dead), removing");
     removePidFile(pidFilePath);
-    return;
+    return null;
   }
 
-  // Process is alive — kill it so we can reclaim the port.
-  logger.info(
-    { stalePid: stale.pid, port: stale.port, startedAt: stale.startedAt },
-    "killing stale dashboard process from previous session",
-  );
+  if (stale.port !== port) {
+    // The recorded owner is on a different port than we want. Don't
+    // adopt it, don't kill it — just treat the pidfile as unrelated.
+    logger.info(
+      { stalePort: stale.port, wantedPort: port },
+      "dashboard pidfile points at different port, ignoring",
+    );
+    removePidFile(pidFilePath);
+    return null;
+  }
+
+  const healthy = await probeDashboardHealth(port);
+  if (healthy) {
+    return { url: `http://127.0.0.1:${port}`, pid: stale.pid };
+  }
 
+  // Zombie: PID is alive but not serving HTTP. Most likely the owner
+  // crashed mid-init or is stuck. Terminate it so we can take over.
+  logger.warn(
+    { stalePid: stale.pid, port },
+    "dashboard pidfile owner is unresponsive, terminating",
+  );
   try {
     process.kill(stale.pid, "SIGTERM");
   } catch {
-    // Permission denied or already gone — remove PID file either way.
-    removePidFile(pidFilePath);
-    return;
+    /* already gone */
   }
-
-  // Wait up to 3 seconds for the process to exit.
   for (let i = 0; i < 30; i++) {
     if (!isPidAlive(stale.pid)) break;
     await new Promise((r) => setTimeout(r, 100));
   }
-
-  // If still alive after 3s, escalate to SIGKILL.
   if (isPidAlive(stale.pid)) {
-    try {
-      process.kill(stale.pid, "SIGKILL");
-    } catch {
-      /* best effort */
-    }
+    try { process.kill(stale.pid, "SIGKILL"); } catch { /* best effort */ }
     await new Promise((r) => setTimeout(r, 200));
   }
-
   removePidFile(pidFilePath);
-
-  // Give the OS a moment to release the TCP port after the process dies.
+  // Let the OS release the TCP port before the caller tries to bind.
   await new Promise((r) => setTimeout(r, 300));
+  return null;
+}
+
+/**
+ * Low-latency health probe. Resolves `true` when the dashboard replies
+ * 2xx to `/api/health` within 500ms, `false` on any other outcome
+ * (timeout, connection refused, 5xx, etc.).
+ */
+async function probeDashboardHealth(port: number): Promise<boolean> {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/health`, {
+      signal: AbortSignal.timeout(500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
 }
 
 // ── Complexity report builder ──────────────────────────────────────

package/src/shared/exclusions.ts

@@ -40,6 +40,17 @@ export const DEFAULT_SKIP_DIRS: ReadonlySet<string> = new Set([
   "artifacts",    // CI artefact staging, Maven
   "publish",      // `dotnet publish` output
 
+  // Test coverage report bundles (generated HTML/JS from coverage tools;
+  // walking them floods the complexity scanner with synthetic minified
+  // functions like `coverage-report/main.js::gG` at CC 80+).
+  "coverage-report",  // ReportGenerator default (.NET)
+  "CoverageReport",   // ReportGenerator PascalCase variant
+  "coveragereport",   // ReportGenerator lowercase fallback
+  "TestResults",      // `dotnet test` default output
+  "cobertura",        // Cobertura XML reporter
+  "lcov-report",      // Istanbul HTML reporter
+  "htmlcov",          // coverage.py HTML output
+
   // Desktop / mobile packaging outputs
   "dist-electron",// Electron-builder
   "release",      // Electron-builder, Tauri