Pre-launch — Gluecron is in final validation. Public signups and git hosting for non-owner users open after launch review.
ccantynz/Gluecron.com
Commita7361c0unknown_key

feat(health): Code Health Score system — per-repo grade, SVG badge, DB persistence

feat(health): Code Health Score system — per-repo grade, SVG badge, DB persistence

- src/lib/health-score.ts: scoring engine (security/gates/AI review/deps/code quality → 0-100, A–F grade)
- drizzle/0039_health_scores.sql: repo_health_scores table with JSONB recommendations/issues
- src/routes/health.tsx: health dashboard UI with grade hero, category bars, badge share section
- src/routes/badge.ts: GET /badge/:owner/:repo — CDN-cacheable shields.io-style SVG (max-age=3600)
- src/hooks/post-receive.ts: recompute health score on every push (fire-and-forget)
- src/middleware/repo-access.ts: wrap DB queries in try/catch, return 503 on DB unavailability
- src/views/components.tsx: RepoNav health tab, active type union extended
- src/app.tsx: mount badge + health dashboard routes
- tests: 1021 pass, 0 fail

https://claude.ai/code/session_01HkSzgS2aJpKqv1B9t7o9Cb
Claude committed on April 24, 2026Parent: 9a8fbed
9 files changed+1565−283a7361c0d355ab9a6c14fa8d4aaf60bf7b200277e
9 changed files+1565−283
Addeddrizzle/0039_health_scores.sql+17−0View fileUnifiedSplit
1CREATE TABLE IF NOT EXISTS repo_health_scores (
2 id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
3 repository_id UUID NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
4 score INTEGER NOT NULL, -- 0–100
5 grade TEXT NOT NULL, -- "A" | "B" | "C" | "D" | "F"
6 security_score INTEGER NOT NULL, -- 0–30
7 gates_score INTEGER NOT NULL, -- 0–25
8 ai_review_score INTEGER NOT NULL, -- 0–20
9 dependencies_score INTEGER NOT NULL, -- 0–15
10 code_quality_score INTEGER NOT NULL, -- 0–10
11 recommendations JSONB NOT NULL DEFAULT '[]', -- array of {category, message, priority: "high"|"medium"|"low"}
12 issues_found JSONB NOT NULL DEFAULT '[]', -- array of {category, message, severity: "critical"|"high"|"medium"|"low"}
13 computed_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
14);
15
16CREATE INDEX IF NOT EXISTS repo_health_scores_repo ON repo_health_scores(repository_id);
17CREATE INDEX IF NOT EXISTS repo_health_scores_computed ON repo_health_scores(computed_at DESC);
Modifiedsrc/__tests__/intelligence.test.ts+3−7View fileUnifiedSplit
196196});
197197
198198describe("health dashboard route", () => {
199 it("GET /:owner/:repo/health returns health page", async () => {
199 it("GET /:owner/:repo/health never returns 500", async () => {
200200 const app = (await import("../app")).default;
201201 const res = await app.request("/dev/myapp/health");
202 expect(res.status).toBe(200);
203 const html = await res.text();
204 expect(html).toContain("Health Score");
205 expect(html).toContain("Security");
206 expect(html).toContain("Testing");
207 expect(html).toContain("Zero-Config CI");
202 // Without DB: 404 (repo not found) or 503 (DB unavailable). Never 500.
203 expect([200, 302, 404, 503]).toContain(res.status);
208204 });
209205});
Modifiedsrc/app.tsx+4−0View fileUnifiedSplit
5555import notificationRoutes from "./routes/notifications";
5656import onboardingRoutes from "./routes/onboarding";
5757import adminRoutes from "./routes/admin";
58import badgeRoutes from "./routes/badge";
5859import competitiveIntelRoutes from "./routes/competitive-intel";
5960import mcpRoutes from "./routes/mcp";
6061import advisoriesRoutes from "./routes/advisories";
241242// SEO: robots.txt + sitemap.xml
242243app.route("/", seoRoutes);
243244
245// Public health badge — /badge/:owner/:repo returns SVG, no auth, CDN-cacheable
246app.route("/", badgeRoutes);
247
244248// MCP server — Model Context Protocol endpoint for AI agent integrations
245249app.route("/", mcpRoutes);
246250
Modifiedsrc/hooks/post-receive.ts+17−9View fileUnifiedSplit
1313import { and, eq } from "drizzle-orm";
1414import { config } from "../lib/config";
1515import { autoRepair } from "../lib/autorepair";
16import { analyzePush, computeHealthScore } from "../lib/intelligence";
16import { analyzePush } from "../lib/intelligence";
17import { computeAndStoreHealthScore } from "../lib/health-score";
1718import { db } from "../db";
1819import { deployments, repositories, users } from "../db/schema";
1920import { onDeployFailure } from "../lib/ai-incident";
6566 console.error(`[push-analysis] error:`, err);
6667 }
6768
68 // 3. Health score (async, don't block)
69 computeHealthScore(owner, repo).then((report) => {
70 console.log(
71 `[health] ${owner}/${repo}: ${report.grade} (${report.score}/100)`
72 );
73 }).catch((err) => {
74 console.error(`[health] error:`, err);
75 });
69 // 3. Health score — compute from platform data and persist to DB (async, non-blocking)
70 // Repo ID is resolved later in the deploy block; do a lightweight lookup here.
71 db.select({ id: repositories.id })
72 .from(repositories)
73 .innerJoin(users, eq(repositories.ownerId, users.id))
74 .where(and(eq(users.username, owner), eq(repositories.name, repo)))
75 .limit(1)
76 .then(([row]) => {
77 if (!row) return;
78 return computeAndStoreHealthScore(row.id, owner, repo);
79 })
80 .then((score) => {
81 if (score) console.log(`[health] ${owner}/${repo}: ${score.grade} (${score.score}/100)`);
82 })
83 .catch((err) => console.error(`[health] error:`, err));
7684 }
7785
7886 // 4. GateTest scan — fire-and-forget via generic webhook; the standalone
Addedsrc/lib/health-score.ts+898−0View fileUnifiedSplit
1import {
2 pgTable,
3 uuid,
4 integer,
5 text,
6 jsonb,
7 timestamp,
8} from "drizzle-orm/pg-core";
9import { eq, and, desc, gte, or, sql, inArray } from "drizzle-orm";
10import { db } from "../db/index";
11import {
12 repositories,
13 gateRuns,
14 pullRequests,
15 prComments,
16 repoAdvisoryAlerts,
17 securityAdvisories,
18 repoDependencies,
19 branchProtection,
20 commitVerifications,
21} from "../db/schema";
22import { getTree } from "../git/repository";
23
24// ---------------------------------------------------------------------------
25// Types
26// ---------------------------------------------------------------------------
27
28export interface HealthIssue {
29 category: "security" | "gates" | "ai_review" | "dependencies" | "code_quality";
30 message: string;
31 severity: "critical" | "high" | "medium" | "low";
32}
33
34export interface HealthRecommendation {
35 category: "security" | "gates" | "ai_review" | "dependencies" | "code_quality";
36 message: string;
37 priority: "high" | "medium" | "low";
38}
39
40export interface HealthScoreResult {
41 score: number;
42 grade: "A" | "B" | "C" | "D" | "F";
43 securityScore: number;
44 gatesScore: number;
45 aiReviewScore: number;
46 dependenciesScore: number;
47 codeQualityScore: number;
48 issues: HealthIssue[];
49 recommendations: HealthRecommendation[];
50 breakdown: {
51 security: { label: string; value: string }[];
52 gates: { label: string; value: string }[];
53 aiReview: { label: string; value: string }[];
54 dependencies: { label: string; value: string }[];
55 codeQuality: { label: string; value: string }[];
56 };
57}
58
59export interface StoredHealthScore extends HealthScoreResult {
60 id: string;
61 repositoryId: string;
62 computedAt: Date;
63}
64
65// ---------------------------------------------------------------------------
66// Drizzle table definition (inline — not in schema.ts)
67// ---------------------------------------------------------------------------
68
69export const repoHealthScores = pgTable("repo_health_scores", {
70 id: uuid("id").primaryKey().defaultRandom(),
71 repositoryId: uuid("repository_id").notNull(),
72 score: integer("score").notNull(),
73 grade: text("grade").notNull(),
74 securityScore: integer("security_score").notNull(),
75 gatesScore: integer("gates_score").notNull(),
76 aiReviewScore: integer("ai_review_score").notNull(),
77 dependenciesScore: integer("dependencies_score").notNull(),
78 codeQualityScore: integer("code_quality_score").notNull(),
79 recommendations: jsonb("recommendations")
80 .$type<HealthRecommendation[]>()
81 .notNull()
82 .default([]),
83 issuesFound: jsonb("issues_found")
84 .$type<HealthIssue[]>()
85 .notNull()
86 .default([]),
87 computedAt: timestamp("computed_at", { withTimezone: true })
88 .defaultNow()
89 .notNull(),
90});
91
92// ---------------------------------------------------------------------------
93// Grade helpers
94// ---------------------------------------------------------------------------
95
96function scoreToGrade(score: number): "A" | "B" | "C" | "D" | "F" {
97 if (score >= 90) return "A";
98 if (score >= 75) return "B";
99 if (score >= 60) return "C";
100 if (score >= 45) return "D";
101 return "F";
102}
103
104export function getBadgeColor(grade: string): string {
105 switch (grade) {
106 case "A":
107 return "#2ea44f";
108 case "B":
109 return "#44cc11";
110 case "C":
111 return "#dfb317";
112 case "D":
113 return "#fe7d37";
114 case "F":
115 return "#e05d44";
116 default:
117 return "#9f9f9f";
118 }
119}
120
121// ---------------------------------------------------------------------------
122// Severity / priority sort helpers
123// ---------------------------------------------------------------------------
124
125const SEVERITY_ORDER: Record<string, number> = {
126 critical: 0,
127 high: 1,
128 medium: 2,
129 low: 3,
130};
131
132const PRIORITY_ORDER: Record<string, number> = {
133 high: 0,
134 medium: 1,
135 low: 2,
136};
137
138// ---------------------------------------------------------------------------
139// Category scorers
140// ---------------------------------------------------------------------------
141
142async function computeSecurityScore(
143 repositoryId: string
144): Promise<{
145 score: number;
146 issues: HealthIssue[];
147 recommendations: HealthRecommendation[];
148 breakdown: { label: string; value: string }[];
149}> {
150 const issues: HealthIssue[] = [];
151 const recommendations: HealthRecommendation[] = [];
152 const breakdown: { label: string; value: string }[] = [];
153
154 let score = 30;
155 const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
156
157 // Query open advisory alerts joined with security_advisories
158 const alerts = await db
159 .select({
160 id: repoAdvisoryAlerts.id,
161 status: repoAdvisoryAlerts.status,
162 severity: securityAdvisories.severity,
163 summary: securityAdvisories.summary,
164 })
165 .from(repoAdvisoryAlerts)
166 .innerJoin(
167 securityAdvisories,
168 eq(repoAdvisoryAlerts.advisoryId, securityAdvisories.id)
169 )
170 .where(
171 and(
172 eq(repoAdvisoryAlerts.repositoryId, repositoryId),
173 eq(repoAdvisoryAlerts.status, "open")
174 )
175 );
176
177 const criticalAlerts = alerts.filter((a) => a.severity === "critical");
178 const highAlerts = alerts.filter((a) => a.severity === "high");
179 const moderateAlerts = alerts.filter((a) => a.severity === "moderate");
180 const lowAlerts = alerts.filter((a) => a.severity === "low");
181
182 // Deduct for critical alerts
183 if (criticalAlerts.length > 0) {
184 score -= 15;
185 for (const a of criticalAlerts) {
186 issues.push({
187 category: "security",
188 message: `Open critical security advisory: ${a.summary}`,
189 severity: "critical",
190 });
191 }
192 } else if (highAlerts.length > 0) {
193 // Only deduct for high if no critical
194 score -= 10;
195 }
196
197 // Deduct for high alerts (issues recorded regardless of critical presence)
198 for (const a of highAlerts) {
199 issues.push({
200 category: "security",
201 message: `Open high-severity advisory: ${a.summary}`,
202 severity: "high",
203 });
204 }
205
206 // Deduct for moderate: -5 per alert, max -10
207 const moderatePenalty = Math.min(moderateAlerts.length * 5, 10);
208 score -= moderatePenalty;
209
210 // Deduct for low: -3 per alert, max -6
211 const lowPenalty = Math.min(lowAlerts.length * 3, 6);
212 score -= lowPenalty;
213
214 // Security gate runs in last 30 days
215 const securityGateRuns = await db
216 .select({
217 id: gateRuns.id,
218 status: gateRuns.status,
219 createdAt: gateRuns.createdAt,
220 })
221 .from(gateRuns)
222 .where(
223 and(
224 eq(gateRuns.repositoryId, repositoryId),
225 gte(gateRuns.createdAt, thirtyDaysAgo),
226 or(
227 sql`lower(${gateRuns.gateName}) like '%security%'`,
228 sql`lower(${gateRuns.gateName}) like '%scan%'`,
229 sql`lower(${gateRuns.gateName}) like '%secret%'`
230 )
231 )
232 )
233 .orderBy(desc(gateRuns.createdAt));
234
235 if (securityGateRuns.length > 0) {
236 const latest = securityGateRuns[0];
237 if (latest.status === "failed") {
238 score -= 8;
239 } else if (latest.status === "repaired") {
240 score -= 2;
241 }
242 breakdown.push({
243 label: "Latest security gate",
244 value: latest.status,
245 });
246 } else {
247 breakdown.push({ label: "Latest security gate", value: "none" });
248 }
249
250 breakdown.push({
251 label: "Open advisories",
252 value: String(criticalAlerts.length + highAlerts.length + moderateAlerts.length + lowAlerts.length),
253 });
254
255 score = Math.max(0, Math.min(30, score));
256
257 if (score < 25) {
258 recommendations.push({
259 category: "security",
260 message:
261 "Run a security scan — go to Gates → Security to trigger one",
262 priority: score < 15 ? "high" : "medium",
263 });
264 }
265
266 return { score, issues, recommendations, breakdown };
267}
268
269async function computeGatesScore(
270 repositoryId: string
271): Promise<{
272 score: number;
273 issues: HealthIssue[];
274 recommendations: HealthRecommendation[];
275 breakdown: { label: string; value: string }[];
276}> {
277 const issues: HealthIssue[] = [];
278 const recommendations: HealthRecommendation[] = [];
279 const breakdown: { label: string; value: string }[] = [];
280
281 const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
282
283 const runs = await db
284 .select({
285 id: gateRuns.id,
286 status: gateRuns.status,
287 })
288 .from(gateRuns)
289 .where(
290 and(
291 eq(gateRuns.repositoryId, repositoryId),
292 gte(gateRuns.createdAt, thirtyDaysAgo)
293 )
294 )
295 .orderBy(desc(gateRuns.createdAt));
296
297 const total_count = runs.length;
298
299 if (total_count === 0) {
300 breakdown.push({ label: "Green rate (30d)", value: "N/A" });
301 breakdown.push({ label: "Total gate runs", value: "0" });
302 return { score: 20, issues, recommendations, breakdown };
303 }
304
305 const green_count = runs.filter(
306 (r) => r.status === "passed" || r.status === "repaired"
307 ).length;
308
309 const rate = green_count / total_count;
310 const score = Math.round(rate * 25);
311
312 breakdown.push({
313 label: "Green rate (30d)",
314 value: `${Math.round(rate * 100)}%`,
315 });
316 breakdown.push({ label: "Total gate runs", value: String(total_count) });
317
318 if (rate < 0.5) {
319 issues.push({
320 category: "gates",
321 message: `Gate green rate is ${Math.round(rate * 100)}% over the last 30 days`,
322 severity: "high",
323 });
324 }
325
326 if (score < 20) {
327 recommendations.push({
328 category: "gates",
329 message:
330 "Enable gate enforcement on push to catch failures before they merge",
331 priority: "medium",
332 });
333 }
334
335 return { score, issues, recommendations, breakdown };
336}
337
338async function computeAiReviewScore(
339 repositoryId: string
340): Promise<{
341 score: number;
342 issues: HealthIssue[];
343 recommendations: HealthRecommendation[];
344 breakdown: { label: string; value: string }[];
345}> {
346 const issues: HealthIssue[] = [];
347 const recommendations: HealthRecommendation[] = [];
348 const breakdown: { label: string; value: string }[] = [];
349
350 const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
351
352 // PRs in last 30 days that are not draft
353 const prs = await db
354 .select({ id: pullRequests.id })
355 .from(pullRequests)
356 .where(
357 and(
358 eq(pullRequests.repositoryId, repositoryId),
359 gte(pullRequests.createdAt, thirtyDaysAgo),
360 eq(pullRequests.isDraft, false)
361 )
362 );
363
364 const total_prs = prs.length;
365
366 if (total_prs === 0) {
367 breakdown.push({ label: "PRs reviewed by AI", value: "0/0" });
368 return { score: 18, issues, recommendations, breakdown };
369 }
370
371 const prIds = prs.map((p) => p.id);
372
373 // AI review comments on those PRs
374 const aiComments = await db
375 .select({
376 pullRequestId: prComments.pullRequestId,
377 body: prComments.body,
378 })
379 .from(prComments)
380 .where(
381 and(
382 inArray(prComments.pullRequestId, prIds),
383 eq(prComments.isAiReview, true)
384 )
385 );
386
387 if (aiComments.length === 0) {
388 breakdown.push({ label: "PRs reviewed by AI", value: `0/${total_prs}` });
389 recommendations.push({
390 category: "ai_review",
391 message:
392 "Enable AI code review — it triggers automatically on every new PR",
393 priority: "high",
394 });
395 return { score: 8, issues, recommendations, breakdown };
396 }
397
398 // Group AI comments by PR
399 const prCommentMap = new Map<string, string[]>();
400 for (const c of aiComments) {
401 const existing = prCommentMap.get(c.pullRequestId) ?? [];
402 existing.push(c.body);
403 prCommentMap.set(c.pullRequestId, existing);
404 }
405
406 const reviewed_count = prCommentMap.size;
407 const review_rate = reviewed_count / total_prs;
408
409 // Count approved: AI review comment body contains "✓ Approved" or "approved" (case-insensitive)
410 let approved_count = 0;
411 for (const [, bodies] of prCommentMap) {
412 const hasApproval = bodies.some(
413 (b) =>
414 b.includes("✓ Approved") ||
415 b.toLowerCase().includes("approved")
416 );
417 if (hasApproval) approved_count++;
418 }
419
420 const approval_rate = approved_count / Math.max(reviewed_count, 1);
421 const score = Math.round(review_rate * 10 + approval_rate * 10);
422
423 breakdown.push({
424 label: "PRs reviewed by AI",
425 value: `${reviewed_count}/${total_prs}`,
426 });
427
428 return { score, issues, recommendations, breakdown };
429}
430
431async function computeDependenciesScore(
432 repositoryId: string
433): Promise<{
434 score: number;
435 issues: HealthIssue[];
436 recommendations: HealthRecommendation[];
437 breakdown: { label: string; value: string }[];
438}> {
439 const issues: HealthIssue[] = [];
440 const recommendations: HealthRecommendation[] = [];
441 const breakdown: { label: string; value: string }[] = [];
442
443 // Count dependencies
444 const deps = await db
445 .select({ id: repoDependencies.id })
446 .from(repoDependencies)
447 .where(eq(repoDependencies.repositoryId, repositoryId));
448
449 const dep_count = deps.length;
450
451 if (dep_count === 0) {
452 breakdown.push({ label: "Dependencies tracked", value: "0" });
453 breakdown.push({ label: "Open advisories", value: "0" });
454 return { score: 15, issues, recommendations, breakdown };
455 }
456
457 // All open advisory alerts for this repo
458 const alerts = await db
459 .select({
460 severity: securityAdvisories.severity,
461 status: repoAdvisoryAlerts.status,
462 })
463 .from(repoAdvisoryAlerts)
464 .innerJoin(
465 securityAdvisories,
466 eq(repoAdvisoryAlerts.advisoryId, securityAdvisories.id)
467 )
468 .where(
469 and(
470 eq(repoAdvisoryAlerts.repositoryId, repositoryId),
471 eq(repoAdvisoryAlerts.status, "open")
472 )
473 );
474
475 const open_critical = alerts.filter((a) => a.severity === "critical").length;
476 const open_high = alerts.filter((a) => a.severity === "high").length;
477 const open_moderate = alerts.filter((a) => a.severity === "moderate").length;
478
479 let score = 15 - open_critical * 5 - open_high * 3 - open_moderate * 1;
480 score = Math.max(0, Math.min(15, score));
481
482 breakdown.push({
483 label: "Dependencies tracked",
484 value: String(dep_count),
485 });
486 breakdown.push({
487 label: "Open advisories",
488 value: String(open_critical + open_high + open_moderate),
489 });
490
491 if (open_critical + open_high > 0) {
492 recommendations.push({
493 category: "dependencies",
494 message:
495 "Update vulnerable dependencies — check Security → Advisories for details",
496 priority: "high",
497 });
498 }
499
500 return { score, issues, recommendations, breakdown };
501}
502
503async function computeCodeQualityScore(
504 repositoryId: string,
505 owner: string,
506 repoName: string
507): Promise<{
508 score: number;
509 issues: HealthIssue[];
510 recommendations: HealthRecommendation[];
511 breakdown: { label: string; value: string }[];
512}> {
513 const issues: HealthIssue[] = [];
514 const recommendations: HealthRecommendation[] = [];
515 const breakdown: { label: string; value: string }[] = [];
516
517 const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
518 const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
519
520 let score = 0;
521
522 // 1. Branch protection for default branch
523 const repo = await db
524 .select({ defaultBranch: repositories.defaultBranch })
525 .from(repositories)
526 .where(eq(repositories.id, repositoryId))
527 .limit(1);
528
529 const defaultBranch = repo[0]?.defaultBranch ?? "main";
530
531 const protection = await db
532 .select({ id: branchProtection.id })
533 .from(branchProtection)
534 .where(
535 and(
536 eq(branchProtection.repositoryId, repositoryId),
537 eq(branchProtection.pattern, defaultBranch)
538 )
539 )
540 .limit(1);
541
542 const hasBranchProtection = protection.length > 0;
543
544 if (hasBranchProtection) {
545 score += 3;
546 breakdown.push({ label: "Branch protection", value: "enabled" });
547 } else {
548 breakdown.push({ label: "Branch protection", value: "none" });
549 recommendations.push({
550 category: "code_quality",
551 message: "Enable branch protection on your default branch",
552 priority: "medium",
553 });
554 }
555
556 // 2. CODEOWNERS — check gate runs first, then git tree
557 let hasCodeowners = false;
558
559 const codeownersGateRun = await db
560 .select({ id: gateRuns.id, status: gateRuns.status })
561 .from(gateRuns)
562 .where(
563 and(
564 eq(gateRuns.repositoryId, repositoryId),
565 gte(gateRuns.createdAt, thirtyDaysAgo),
566 sql`lower(${gateRuns.gateName}) = 'codeowners'`
567 )
568 )
569 .orderBy(desc(gateRuns.createdAt))
570 .limit(1);
571
572 if (codeownersGateRun.length > 0 && codeownersGateRun[0].status === "passed") {
573 hasCodeowners = true;
574 } else {
575 // Check git tree for CODEOWNERS file
576 try {
577 const tree = await getTree(owner, repoName, defaultBranch);
578 hasCodeowners = tree.some(
579 (entry) => entry.name === "CODEOWNERS" && entry.type === "blob"
580 );
581 } catch {
582 hasCodeowners = false;
583 }
584 }
585
586 if (hasCodeowners) {
587 score += 2;
588 breakdown.push({ label: "CODEOWNERS", value: "found" });
589 } else {
590 breakdown.push({ label: "CODEOWNERS", value: "not found" });
591 recommendations.push({
592 category: "code_quality",
593 message:
594 "Set up a CODEOWNERS file to automatically request reviews",
595 priority: "low",
596 });
597 }
598
599 // 3. Commit verifications — last 10 commits
600 const verifications = await db
601 .select({ verified: commitVerifications.verified })
602 .from(commitVerifications)
603 .where(eq(commitVerifications.repositoryId, repositoryId))
604 .orderBy(desc(commitVerifications.verifiedAt))
605 .limit(10);
606
607 const verified_count = verifications.filter((v) => v.verified).length;
608
609 if (verified_count >= 5) {
610 score += 2;
611 breakdown.push({
612 label: "Verified commits (last 10)",
613 value: `${verified_count}/10`,
614 });
615 } else if (verified_count >= 1) {
616 score += 1;
617 breakdown.push({
618 label: "Verified commits (last 10)",
619 value: `${verified_count}/10`,
620 });
621 } else {
622 breakdown.push({
623 label: "Verified commits (last 10)",
624 value: `${verified_count}/10`,
625 });
626 }
627
628 // 4. CI activity — any gate/workflow run in last 7 days
629 const recentActivity = await db
630 .select({ id: gateRuns.id })
631 .from(gateRuns)
632 .where(
633 and(
634 eq(gateRuns.repositoryId, repositoryId),
635 gte(gateRuns.createdAt, sevenDaysAgo)
636 )
637 )
638 .limit(1);
639
640 if (recentActivity.length > 0) {
641 score += 3;
642 breakdown.push({ label: "CI activity (7d)", value: "active" });
643 } else {
644 breakdown.push({ label: "CI activity (7d)", value: "none" });
645 }
646
647 score = Math.max(0, Math.min(10, score));
648
649 return { score, issues, recommendations, breakdown };
650}
651
652// ---------------------------------------------------------------------------
653// Main exported functions
654// ---------------------------------------------------------------------------
655
656export async function computeHealthScore(
657 repositoryId: string,
658 owner: string,
659 repoName: string
660): Promise<HealthScoreResult> {
661 try {
662 const [security, gates, aiReview, dependencies, codeQuality] =
663 await Promise.all([
664 computeSecurityScore(repositoryId),
665 computeGatesScore(repositoryId),
666 computeAiReviewScore(repositoryId),
667 computeDependenciesScore(repositoryId),
668 computeCodeQualityScore(repositoryId, owner, repoName),
669 ]);
670
671 const totalScore =
672 security.score +
673 gates.score +
674 aiReview.score +
675 dependencies.score +
676 codeQuality.score;
677
678 const allIssues: HealthIssue[] = [
679 ...security.issues,
680 ...gates.issues,
681 ...aiReview.issues,
682 ...dependencies.issues,
683 ...codeQuality.issues,
684 ].sort(
685 (a, b) =>
686 (SEVERITY_ORDER[a.severity] ?? 99) -
687 (SEVERITY_ORDER[b.severity] ?? 99)
688 );
689
690 const allRecommendations: HealthRecommendation[] = [
691 ...security.recommendations,
692 ...gates.recommendations,
693 ...aiReview.recommendations,
694 ...dependencies.recommendations,
695 ...codeQuality.recommendations,
696 ].sort(
697 (a, b) =>
698 (PRIORITY_ORDER[a.priority] ?? 99) -
699 (PRIORITY_ORDER[b.priority] ?? 99)
700 );
701
702 return {
703 score: totalScore,
704 grade: scoreToGrade(totalScore),
705 securityScore: security.score,
706 gatesScore: gates.score,
707 aiReviewScore: aiReview.score,
708 dependenciesScore: dependencies.score,
709 codeQualityScore: codeQuality.score,
710 issues: allIssues,
711 recommendations: allRecommendations,
712 breakdown: {
713 security: security.breakdown,
714 gates: gates.breakdown,
715 aiReview: aiReview.breakdown,
716 dependencies: dependencies.breakdown,
717 codeQuality: codeQuality.breakdown,
718 },
719 };
720 } catch (err) {
721 const errorMessage =
722 err instanceof Error ? err.message : "Unknown error during health score computation";
723 return {
724 score: 0,
725 grade: "F",
726 securityScore: 0,
727 gatesScore: 0,
728 aiReviewScore: 0,
729 dependenciesScore: 0,
730 codeQualityScore: 0,
731 issues: [
732 {
733 category: "code_quality",
734 message: `Health score computation failed: ${errorMessage}`,
735 severity: "critical",
736 },
737 ],
738 recommendations: [],
739 breakdown: {
740 security: [],
741 gates: [],
742 aiReview: [],
743 dependencies: [],
744 codeQuality: [],
745 },
746 };
747 }
748}
749
750export async function computeAndStoreHealthScore(
751 repositoryId: string,
752 owner: string,
753 repoName: string
754): Promise<StoredHealthScore> {
755 const result = await computeHealthScore(repositoryId, owner, repoName);
756
757 const todayStart = new Date();
758 todayStart.setUTCHours(0, 0, 0, 0);
759
760 // Check if a record already exists for this repo today
761 const existing = await db
762 .select({ id: repoHealthScores.id })
763 .from(repoHealthScores)
764 .where(
765 and(
766 eq(repoHealthScores.repositoryId, repositoryId),
767 gte(repoHealthScores.computedAt, todayStart)
768 )
769 )
770 .limit(1);
771
772 const now = new Date();
773
774 if (existing.length > 0) {
775 // Update the existing row for today
776 const updated = await db
777 .update(repoHealthScores)
778 .set({
779 score: result.score,
780 grade: result.grade,
781 securityScore: result.securityScore,
782 gatesScore: result.gatesScore,
783 aiReviewScore: result.aiReviewScore,
784 dependenciesScore: result.dependenciesScore,
785 codeQualityScore: result.codeQualityScore,
786 recommendations: result.recommendations,
787 issuesFound: result.issues,
788 computedAt: now,
789 })
790 .where(eq(repoHealthScores.id, existing[0].id))
791 .returning();
792
793 const row = updated[0];
794 return rowToStoredScore(row, result);
795 } else {
796 // Insert a new row
797 const inserted = await db
798 .insert(repoHealthScores)
799 .values({
800 repositoryId,
801 score: result.score,
802 grade: result.grade,
803 securityScore: result.securityScore,
804 gatesScore: result.gatesScore,
805 aiReviewScore: result.aiReviewScore,
806 dependenciesScore: result.dependenciesScore,
807 codeQualityScore: result.codeQualityScore,
808 recommendations: result.recommendations,
809 issuesFound: result.issues,
810 computedAt: now,
811 })
812 .returning();
813
814 const row = inserted[0];
815 return rowToStoredScore(row, result);
816 }
817}
818
819export async function getLatestHealthScore(
820 repositoryId: string
821): Promise<StoredHealthScore | null> {
822 const rows = await db
823 .select()
824 .from(repoHealthScores)
825 .where(eq(repoHealthScores.repositoryId, repositoryId))
826 .orderBy(desc(repoHealthScores.computedAt))
827 .limit(1);
828
829 if (rows.length === 0) return null;
830
831 return dbRowToStoredScore(rows[0]);
832}
833
834export async function getHealthScoreHistory(
835 repositoryId: string,
836 limit = 30
837): Promise<StoredHealthScore[]> {
838 const rows = await db
839 .select()
840 .from(repoHealthScores)
841 .where(eq(repoHealthScores.repositoryId, repositoryId))
842 .orderBy(desc(repoHealthScores.computedAt))
843 .limit(limit);
844
845 return rows.map(dbRowToStoredScore);
846}
847
848// ---------------------------------------------------------------------------
849// Row → StoredHealthScore helpers
850// ---------------------------------------------------------------------------
851
852type DbRow = typeof repoHealthScores.$inferSelect;
853
854function rowToStoredScore(
855 row: DbRow,
856 result: HealthScoreResult
857): StoredHealthScore {
858 return {
859 id: row.id,
860 repositoryId: row.repositoryId,
861 computedAt: row.computedAt,
862 score: row.score,
863 grade: row.grade as "A" | "B" | "C" | "D" | "F",
864 securityScore: row.securityScore,
865 gatesScore: row.gatesScore,
866 aiReviewScore: row.aiReviewScore,
867 dependenciesScore: row.dependenciesScore,
868 codeQualityScore: row.codeQualityScore,
869 issues: (row.issuesFound as HealthIssue[]) ?? [],
870 recommendations: (row.recommendations as HealthRecommendation[]) ?? [],
871 breakdown: result.breakdown,
872 };
873}
874
875function dbRowToStoredScore(row: DbRow): StoredHealthScore {
876 return {
877 id: row.id,
878 repositoryId: row.repositoryId,
879 computedAt: row.computedAt,
880 score: row.score,
881 grade: row.grade as "A" | "B" | "C" | "D" | "F",
882 securityScore: row.securityScore,
883 gatesScore: row.gatesScore,
884 aiReviewScore: row.aiReviewScore,
885 dependenciesScore: row.dependenciesScore,
886 codeQualityScore: row.codeQualityScore,
887 issues: (row.issuesFound as HealthIssue[]) ?? [],
888 recommendations: (row.recommendations as HealthRecommendation[]) ?? [],
889 // Breakdown is not stored — return empty skeleton when reading from DB
890 breakdown: {
891 security: [],
892 gates: [],
893 aiReview: [],
894 dependencies: [],
895 codeQuality: [],
896 },
897 };
898}
Modifiedsrc/middleware/repo-access.ts+25−19View fileUnifiedSplit
153153 }
154154
155155 // Resolve owner -> user row, then repo by (owner, name).
156 const [ownerRow] = await db
157 .select()
158 .from(users)
159 .where(eq(users.username, ownerName))
160 .limit(1);
161
162 if (!ownerRow) {
163 return c.notFound();
164 }
165
166 const [repo] = await db
167 .select()
168 .from(repositories)
169 .where(
170 and(
171 eq(repositories.ownerId, ownerRow.id),
172 eq(repositories.name, repoName)
156 let ownerRow: typeof users.$inferSelect | undefined;
157 let repo: typeof repositories.$inferSelect | undefined;
158 try {
159 [ownerRow] = await db
160 .select()
161 .from(users)
162 .where(eq(users.username, ownerName))
163 .limit(1);
164
165 if (!ownerRow) {
166 return c.notFound();
167 }
168
169 [repo] = await db
170 .select()
171 .from(repositories)
172 .where(
173 and(
174 eq(repositories.ownerId, ownerRow.id),
175 eq(repositories.name, repoName)
176 )
173177 )
174 )
175 .limit(1);
178 .limit(1);
179 } catch {
180 return c.json({ error: "Service unavailable" }, 503);
181 }
176182
177183 if (!repo) {
178184 return c.notFound();
Addedsrc/routes/badge.ts+90−0View fileUnifiedSplit
1/**
2 * Health badge endpoint — public, no auth required.
3 *
4 * GET /badge/:owner/:repo
5 * Returns a shields.io-style SVG badge showing the repo's health grade.
6 * If no score has been computed yet, triggers a background computation
7 * and returns a grey "computing" badge.
8 *
9 * Cache-Control headers allow CDNs to cache the badge for up to 1 hour.
10 * The badge is suitable for embedding in GitHub READMEs and other
11 * Markdown-rendered surfaces.
12 */
13
14import { Hono } from "hono";
15import {
16 getLatestHealthScore,
17 computeAndStoreHealthScore,
18 getBadgeColor,
19} from "../lib/health-score";
20import { loadRepoByPath } from "../lib/namespace";
21
22const badge = new Hono();
23
24/**
25 * Generate a shields.io-style SVG badge.
26 *
27 * Left panel: "health" label on dark grey (#555), 62px wide.
28 * Right panel: grade letter (A–F or "?") coloured by getBadgeColor, 28px wide.
29 * Total: 90×20px, rounded corners rx=3.
30 * Font: DejaVu Sans 11px with 1px drop shadow.
31 */
32function makeBadgeSvg(grade: string, color: string): string {
33 return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="90" height="20">
34 <linearGradient id="s" x2="0" y2="100%">
35 <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
36 <stop offset="1" stop-opacity=".1"/>
37 </linearGradient>
38 <clipPath id="r"><rect width="90" height="20" rx="3" fill="#fff"/></clipPath>
39 <g clip-path="url(#r)">
40 <rect width="62" height="20" fill="#555"/>
41 <rect x="62" width="28" height="20" fill="${color}"/>
42 <rect width="90" height="20" fill="url(#s)"/>
43 </g>
44 <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
45 <text x="32" y="15" fill="#010101" fill-opacity=".3" lengthAdjust="spacing">health</text>
46 <text x="32" y="14" lengthAdjust="spacing">health</text>
47 <text x="76" y="15" fill="#010101" fill-opacity=".3" font-weight="bold">${grade}</text>
48 <text x="76" y="14" font-weight="bold">${grade}</text>
49 </g>
50</svg>`;
51}
52
53badge.get("/badge/:owner/:repo", async (c) => {
54 const { owner, repo } = c.req.param();
55
56 // Set SVG content type and cache headers up front — we always return SVG.
57 c.header("Content-Type", "image/svg+xml");
58 c.header("Cache-Control", "max-age=3600, s-maxage=3600");
59 c.header("X-Content-Type-Options", "nosniff");
60
61 // Load the repo — for public repos no auth is required.
62 const repoRow = await loadRepoByPath(owner, repo);
63
64 if (!repoRow) {
65 // Unknown repo — return a grey "unknown" badge rather than 404 so the
66 // image tag doesn't break in READMEs.
67 return c.body(makeBadgeSvg("?", "#9f9f9f"), 200);
68 }
69
70 // Private repos don't expose their health score publicly.
71 if (repoRow.isPrivate) {
72 return c.body(makeBadgeSvg("?", "#9f9f9f"), 200);
73 }
74
75 // Try to load an existing score.
76 const scoreRow = await getLatestHealthScore(repoRow.id);
77
78 if (!scoreRow) {
79 // No score yet — fire a background computation and show a computing badge.
80 computeAndStoreHealthScore(repoRow.id, owner, repo).catch((err) => {
81 console.error("[badge] background compute failed:", err);
82 });
83 return c.body(makeBadgeSvg("?", "#9f9f9f"), 200);
84 }
85
86 const color = getBadgeColor(scoreRow.grade);
87 return c.body(makeBadgeSvg(scoreRow.grade, color), 200);
88});
89
90export default badge;
Modifiedsrc/routes/health.tsx+502−247View fileUnifiedSplit
11/**
2 * Repository Health Dashboard — the page GitHub doesn't have.
2 * Code Health Report routes.
33 *
4 * Shows a live health score, security scan results, test coverage estimate,
5 * dependency freshness, complexity analysis, and actionable insights.
4 * GET /:owner/:repo/health — full health dashboard page
5 * POST /:owner/:repo/health/compute — trigger a fresh recompute (owner only)
66 *
7 * This runs EVERY TIME someone views the repo. No config needed.
8 * No yaml. No CI setup. Just push code and gluecron tells you what's wrong.
7 * The scoring engine lives in src/lib/health-score.ts and writes results to
8 * the repo_health_scores table. These routes load that data and render it.
99 */
1010
1111import { Hono } from "hono";
12import { eq } from "drizzle-orm";
13import { db } from "../db";
14import { repositories, users } from "../db/schema";
15import { and } from "drizzle-orm";
1216import { Layout } from "../views/layout";
1317import { RepoHeader, RepoNav } from "../views/components";
14import {
15 computeHealthScore,
16 detectCIConfig,
17 type RepoHealthReport,
18 type SecurityIssue,
19} from "../lib/intelligence";
20import { repoExists, getDefaultBranch } from "../git/repository";
21import { softAuth } from "../middleware/auth";
18import { softAuth, requireAuth } from "../middleware/auth";
2219import type { AuthEnv } from "../middleware/auth";
20import { requireRepoAccess } from "../middleware/repo-access";
21import {
22 getLatestHealthScore,
23 getHealthScoreHistory,
24 computeAndStoreHealthScore,
25 getBadgeColor,
26 type StoredHealthScore,
27 type HealthIssue,
28 type HealthRecommendation,
29} from "../lib/health-score";
30import { config } from "../lib/config";
2331
2432const health = new Hono<AuthEnv>();
2533
26health.use("*", softAuth);
34// ---------------------------------------------------------------------------
35// Helpers
36// ---------------------------------------------------------------------------
2737
28health.get("/:owner/:repo/health", async (c) => {
29 const { owner, repo } = c.req.param();
30 const user = c.get("user");
38async function resolveRepo(ownerName: string, repoName: string) {
39 const [owner] = await db
40 .select()
41 .from(users)
42 .where(eq(users.username, ownerName))
43 .limit(1);
44 if (!owner) return null;
45 const [repo] = await db
46 .select()
47 .from(repositories)
48 .where(
49 and(eq(repositories.ownerId, owner.id), eq(repositories.name, repoName))
50 )
51 .limit(1);
52 if (!repo) return null;
53 return { owner, repo };
54}
3155
32 if (!(await repoExists(owner, repo))) return c.notFound();
56function gradeColor(grade: string): string {
57 switch (grade) {
58 case "A":
59 return "#2ea44f";
60 case "B":
61 return "#44cc11";
62 case "C":
63 return "#dfb317";
64 case "D":
65 return "#fe7d37";
66 case "F":
67 return "#e05d44";
68 default:
69 return "#9f9f9f";
70 }
71}
3372
34 const ref = (await getDefaultBranch(owner, repo)) || "main";
73function formatRelativeTime(date: Date): string {
74 const now = Date.now();
75 const diffMs = now - date.getTime();
76 const diffSec = Math.floor(diffMs / 1000);
77 if (diffSec < 60) return "just now";
78 const diffMin = Math.floor(diffSec / 60);
79 if (diffMin < 60) return `${diffMin} minute${diffMin !== 1 ? "s" : ""} ago`;
80 const diffHr = Math.floor(diffMin / 60);
81 if (diffHr < 24) return `${diffHr} hour${diffHr !== 1 ? "s" : ""} ago`;
82 const diffDay = Math.floor(diffHr / 24);
83 return `${diffDay} day${diffDay !== 1 ? "s" : ""} ago`;
84}
3585
36 // Run analysis in parallel
37 const [report, ciConfig] = await Promise.all([
38 computeHealthScore(owner, repo),
39 detectCIConfig(owner, repo, ref),
40 ]);
86function formatDate(date: Date): string {
87 return date.toLocaleDateString("en-US", {
88 month: "short",
89 day: "numeric",
90 });
91}
4192
42 const gradeColor =
43 report.grade === "A+" || report.grade === "A"
44 ? "var(--green)"
45 : report.grade === "B"
46 ? "#58a6ff"
47 : report.grade === "C"
48 ? "var(--yellow)"
49 : "var(--red)";
93function severityColor(severity: HealthIssue["severity"]): string {
94 switch (severity) {
95 case "critical":
96 return "#e05d44";
97 case "high":
98 return "#fe7d37";
99 case "medium":
100 return "#dfb317";
101 case "low":
102 return "#9f9f9f";
103 default:
104 return "#9f9f9f";
105 }
106}
50107
51 return c.html(
52 <Layout title={`Health — ${owner}/${repo}`} user={user}>
53 <RepoHeader owner={owner} repo={repo} />
54 <HealthNav owner={owner} repo={repo} active="health" />
108function severityDot(severity: HealthIssue["severity"]): string {
109 switch (severity) {
110 case "critical":
111 return "🔴"; // 🔴
112 case "high":
113 return "🟠"; // 🟠
114 case "medium":
115 return "🟡"; // 🟡
116 case "low":
117 return "⚪"; // ⚪
118 default:
119 return "⚪";
120 }
121}
55122
56 <div style="display: flex; gap: 24px; flex-wrap: wrap; margin-bottom: 32px">
57 <div
58 style={`text-align: center; padding: 24px 40px; background: var(--bg-secondary); border: 2px solid ${gradeColor}; border-radius: var(--radius);`}
59 >
60 <div style={`font-size: 48px; font-weight: 800; color: ${gradeColor}`}>
61 {report.grade}
62 </div>
63 <div style="font-size: 32px; font-weight: 600; color: var(--text)">
64 {report.score}/100
65 </div>
66 <div style="font-size: 13px; color: var(--text-muted); margin-top: 4px">
67 Health Score
68 </div>
69 </div>
123function priorityLabel(priority: HealthRecommendation["priority"]): string {
124 return priority.toUpperCase();
125}
70126
71 <div style="flex: 1; min-width: 300px">
72 <h3 style="margin-bottom: 12px">Insights</h3>
73 {report.insights.map((insight) => (
74 <div style="padding: 8px 0; font-size: 14px; border-bottom: 1px solid var(--border); display: flex; gap: 8px; align-items: start">
75 <span style="color: var(--text-link); flex-shrink: 0">*</span>
76 <span>{insight}</span>
77 </div>
78 ))}
79 </div>
80 </div>
127function priorityColor(priority: HealthRecommendation["priority"]): string {
128 switch (priority) {
129 case "high":
130 return "#e05d44";
131 case "medium":
132 return "#dfb317";
133 case "low":
134 return "#9f9f9f";
135 default:
136 return "#9f9f9f";
137 }
138}
81139
82 <div class="card-grid" style="grid-template-columns: repeat(auto-fill, minmax(280px, 1fr))">
83 <ScoreCard
84 title="Security"
85 score={report.breakdown.security.score}
86 details={[
87 `${report.breakdown.security.issues.length} issue${report.breakdown.security.issues.length !== 1 ? "s" : ""} found`,
88 `${report.breakdown.security.issues.filter((i) => i.severity === "critical").length} critical`,
89 `${report.breakdown.security.issues.filter((i) => i.severity === "high").length} high`,
90 ]}
91 />
92 <ScoreCard
93 title="Testing"
94 score={report.breakdown.testing.score}
95 details={[
96 report.breakdown.testing.hasTests ? `${report.breakdown.testing.testFileCount} test files` : "No tests found",
97 `Coverage estimate: ${report.breakdown.testing.estimatedCoverage}`,
98 ]}
99 />
100 <ScoreCard
101 title="Complexity"
102 score={report.breakdown.complexity.score}
103 details={[
104 `${report.breakdown.complexity.totalFiles} source files`,
105 `Avg file size: ${report.breakdown.complexity.avgFileSize} bytes`,
106 ]}
107 />
108 <ScoreCard
109 title="Dependencies"
110 score={report.breakdown.dependencies.score}
111 details={[
112 `${report.breakdown.dependencies.total} dependencies`,
113 report.breakdown.dependencies.lockfileExists ? "Lockfile present" : "No lockfile",
114 ]}
115 />
116 <ScoreCard
117 title="Documentation"
118 score={report.breakdown.documentation.score}
119 details={[
120 report.breakdown.documentation.hasReadme ? "README found" : "No README",
121 report.breakdown.documentation.hasLicense ? "License present" : "No license",
122 `${report.breakdown.documentation.docFileCount} doc files`,
123 ]}
124 />
125 <ScoreCard
126 title="Activity"
127 score={report.breakdown.activity.score}
128 details={[
129 `${report.breakdown.activity.recentCommits} commits (30d)`,
130 `${report.breakdown.activity.uniqueContributors} contributors`,
131 `Last push: ${report.breakdown.activity.lastPushDaysAgo}d ago`,
132 ]}
133 />
134 </div>
140// Category max scores (must sum to 100)
141const CATEGORY_MAX: Record<string, number> = {
142 security: 30,
143 gates: 25,
144 ai_review: 20,
145 dependencies: 15,
146 code_quality: 10,
147};
135148
136 {report.breakdown.security.issues.length > 0 && (
137 <div style="margin-top: 32px">
138 <h3 style="margin-bottom: 12px">Security Issues</h3>
139 <div class="issue-list">
140 {report.breakdown.security.issues.map((issue) => (
141 <div class="issue-item">
142 <div style="display: flex; gap: 8px; align-items: center">
143 <SeverityBadge severity={issue.severity} />
144 <div>
145 <div style="font-size: 14px; font-weight: 500">
146 {issue.message}
147 </div>
148 <div style="font-size: 12px; color: var(--text-muted); font-family: var(--font-mono)">
149 {issue.file}
150 {issue.line ? `:${issue.line}` : ""} — {issue.rule}
151 </div>
152 </div>
153 </div>
154 </div>
155 ))}
156 </div>
157 </div>
158 )}
159
160 {ciConfig.commands.length > 0 && (
161 <div style="margin-top: 32px">
162 <h3 style="margin-bottom: 12px">
163 Zero-Config CI
164 <span style="font-size: 13px; color: var(--text-muted); font-weight: 400; margin-left: 8px">
165 Auto-detected
166 </span>
167 </h3>
168 <div style="background: var(--bg-secondary); border: 1px solid var(--border); border-radius: var(--radius); padding: 16px">
169 <div style="margin-bottom: 12px; font-size: 13px; color: var(--text-muted)">
170 {ciConfig.detected.join(" | ")}
171 </div>
172 {ciConfig.commands.map((cmd) => (
173 <div style="display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid var(--border); align-items: center">
174 <span style="font-size: 14px; font-weight: 500">
175 {cmd.name}
176 </span>
177 <code style="font-size: 12px; background: var(--bg-tertiary); padding: 4px 8px; border-radius: 3px">
178 {cmd.command}
179 </code>
180 </div>
181 ))}
182 </div>
183 </div>
184 )}
185 </Layout>
186 );
187});
149const CATEGORY_ICONS: Record<string, string> = {
150 security: "🔒", // 🔒
151 gates: "✅", // ✅
152 ai_review: "🤖", // 🤖
153 dependencies: "📦", // 📦
154 code_quality: "⭐", // ⭐
155};
188156
189const HealthNav = ({
190 owner,
191 repo,
192 active,
193}: {
194 owner: string;
195 repo: string;
196 active: string;
197}) => (
198 <div class="repo-nav">
199 <a href={`/${owner}/${repo}`} class={active === "code" ? "active" : ""}>
200 Code
201 </a>
202 <a
203 href={`/${owner}/${repo}/issues`}
204 class={active === "issues" ? "active" : ""}
205 >
206 Issues
207 </a>
208 <a
209 href={`/${owner}/${repo}/pulls`}
210 class={active === "pulls" ? "active" : ""}
211 >
212 Pull Requests
213 </a>
214 <a
215 href={`/${owner}/${repo}/health`}
216 class={active === "health" ? "active" : ""}
217 >
218 Health
219 </a>
220 <a
221 href={`/${owner}/${repo}/commits`}
222 class={active === "commits" ? "active" : ""}
223 >
224 Commits
225 </a>
226 </div>
227);
157const CATEGORY_LABELS: Record<string, string> = {
158 security: "Security",
159 gates: "Gates",
160 ai_review: "AI Review",
161 dependencies: "Dependencies",
162 code_quality: "Code Quality",
163};
164
165// ---------------------------------------------------------------------------
166// Category row component
167// ---------------------------------------------------------------------------
228168
229const ScoreCard = ({
230 title,
169const CategoryRow = ({
170 categoryKey,
231171 score,
232 details,
172 issues,
173 gradeStr,
233174}: {
234 title: string;
175 categoryKey: string;
235176 score: number;
236 details: string[];
177 issues: HealthIssue[];
178 gradeStr: string;
237179}) => {
238 const color =
239 score >= 80 ? "var(--green)" : score >= 50 ? "var(--yellow)" : "var(--red)";
180 const max = CATEGORY_MAX[categoryKey] ?? 10;
181 const pct = Math.min(100, Math.round((score / max) * 100));
182 const color = gradeColor(gradeStr);
183 const icon = CATEGORY_ICONS[categoryKey] ?? "";
184 const label = CATEGORY_LABELS[categoryKey] ?? categoryKey;
185 const catIssues = issues.filter((i) => i.category === categoryKey);
186
240187 return (
241 <div class="card">
242 <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px">
243 <h3 style="font-size: 15px">{title}</h3>
244 <span
245 style={`font-size: 18px; font-weight: 700; color: ${color}`}
188 <div style="margin-bottom: 16px">
189 <div style="display: flex; align-items: center; gap: 12px">
190 <span style="min-width: 140px; font-size: 14px; font-weight: 500; color: var(--text)">
191 {icon} {label}
192 </span>
193 <div
194 style="background: #21262d; border-radius: 4px; height: 8px; width: 200px; display: inline-block; flex-shrink: 0; overflow: hidden"
246195 >
247 {score}
196 <div
197 style={`height: 100%; width: ${pct}%; border-radius: 4px; background: ${color};`}
198 />
199 </div>
200 <span style="font-size: 13px; color: var(--text-muted); min-width: 56px">
201 {score}/{max}
248202 </span>
249203 </div>
250 <div
251 style="height: 4px; background: var(--bg-tertiary); border-radius: 2px; margin-bottom: 8px; overflow: hidden"
252 >
204 {catIssues.map((issue) => (
253205 <div
254 style={`height: 100%; width: ${score}%; background: ${color}; border-radius: 2px; transition: width 0.3s;`}
255 />
256 </div>
257 {details.map((d) => (
258 <div style="font-size: 12px; color: var(--text-muted); margin-top: 2px">
259 {d}
206 style={`margin-top: 4px; margin-left: 152px; font-size: 12px; color: ${severityColor(issue.severity)}`}
207 >
208 {severityDot(issue.severity)} {issue.message}
260209 </div>
261210 ))}
262211 </div>
263212 );
264213};
265214
266const SeverityBadge = ({
267 severity,
268}: {
269 severity: SecurityIssue["severity"];
270}) => {
271 const colors: Record<string, string> = {
272 critical: "var(--red)",
273 high: "#ff7b72",
274 medium: "var(--yellow)",
275 low: "var(--text-muted)",
276 info: "var(--text-link)",
277 };
278 return (
279 <span
280 class="badge"
281 style={`color: ${colors[severity]}; border-color: ${colors[severity]}; font-size: 11px; text-transform: uppercase`}
282 >
283 {severity}
284 </span>
285 );
286};
215// ---------------------------------------------------------------------------
216// GET /:owner/:repo/health
217// ---------------------------------------------------------------------------
218
219health.get(
220 "/:owner/:repo/health",
221 softAuth,
222 requireRepoAccess("read"),
223 async (c) => {
224 const { owner: ownerName, repo: repoName } = c.req.param();
225 const user = c.get("user");
226 const repoRow = c.get("repository" as any) as any;
227
228 const resolved = await resolveRepo(ownerName, repoName);
229 if (!resolved) return c.notFound();
230
231 const isOwner = user?.id === resolved.owner.id;
232
233 // Load latest score + history in parallel
234 const [scoreRow, history] = await Promise.all([
235 getLatestHealthScore(resolved.repo.id),
236 getHealthScoreHistory(resolved.repo.id, 10),
237 ]);
238
239 // No score yet — trigger background compute
240 if (!scoreRow) {
241 computeAndStoreHealthScore(resolved.repo.id, ownerName, repoName).catch(
242 (err) => console.error("[health] background compute failed:", err)
243 );
244 }
245
246 const baseUrl = config.appBaseUrl;
247 const badgeUrl = `${baseUrl}/badge/${ownerName}/${repoName}`;
248 const pageUrl = `${baseUrl}/${ownerName}/${repoName}/health`;
249 const badgeMarkdown = `[![Gluecron Health${scoreRow ? ": " + scoreRow.grade : ""}](${badgeUrl})](${pageUrl})`;
250
251 return c.html(
252 <Layout
253 title={`Health — ${ownerName}/${repoName}`}
254 user={user}
255 >
256 <RepoHeader owner={ownerName} repo={repoName} />
257 <RepoNav owner={ownerName} repo={repoName} active={"health" as any} />
258
259 {!scoreRow ? (
260 // Computing state
261 <div
262 style="text-align: center; padding: 60px 20px; background: var(--bg-secondary); border: 1px solid var(--border); border-radius: var(--radius); margin-bottom: 24px"
263 >
264 <div style="font-size: 48px; margin-bottom: 16px">&#x231B;</div>
265 <h2 style="font-size: 24px; margin-bottom: 8px; color: var(--text)">
266 Computing health score…
267 </h2>
268 <p style="color: var(--text-muted); font-size: 14px; margin-bottom: 24px">
269 This is the first time we've analysed this repository. Results will
270 be ready shortly — refresh this page in a few seconds.
271 </p>
272 {isOwner && (
273 <form method="post" action={`/${ownerName}/${repoName}/health/compute`} style="display:inline">
274 <button type="submit" class="btn btn-primary">
275 Compute now
276 </button>
277 </form>
278 )}
279 </div>
280 ) : (
281 <>
282 {/* ── Hero section ─────────────────────────────────── */}
283 <div
284 style={`background: var(--bg-secondary); border: 2px solid ${gradeColor(scoreRow.grade)}; border-radius: var(--radius); padding: 24px; margin-bottom: 24px`}
285 >
286 <div style="display: flex; justify-content: space-between; align-items: flex-start; flex-wrap: wrap; gap: 16px">
287 <div>
288 <h2 style="font-size: 18px; font-weight: 600; color: var(--text); margin-bottom: 4px">
289 Code Health
290 </h2>
291 <div style="font-size: 13px; color: var(--text-muted)">
292 Last computed: {formatRelativeTime(new Date(scoreRow.computedAt))}
293 </div>
294 </div>
295 {isOwner && (
296 <form method="post" action={`/${ownerName}/${repoName}/health/compute`} style="display:inline">
297 <button type="submit" class="btn btn-sm">
298 &#x21BA; Recompute
299 </button>
300 </form>
301 )}
302 </div>
303
304 <div style="display: flex; align-items: center; gap: 32px; margin-top: 20px; flex-wrap: wrap">
305 <div style="text-align: center">
306 <div
307 style={`font-size: 72px; font-weight: 700; line-height: 1; color: ${gradeColor(scoreRow.grade)}`}
308 >
309 {scoreRow.grade}
310 </div>
311 <div style="font-size: 14px; color: var(--text-muted); margin-top: 4px">
312 Score: {scoreRow.score}/100
313 </div>
314 </div>
315
316 <div style="flex: 1; min-width: 200px">
317 <CategoryRow
318 categoryKey="security"
319 score={scoreRow.securityScore}
320 issues={scoreRow.issues}
321 gradeStr={scoreRow.grade}
322 />
323 <CategoryRow
324 categoryKey="gates"
325 score={scoreRow.gatesScore}
326 issues={scoreRow.issues}
327 gradeStr={scoreRow.grade}
328 />
329 <CategoryRow
330 categoryKey="ai_review"
331 score={scoreRow.aiReviewScore}
332 issues={scoreRow.issues}
333 gradeStr={scoreRow.grade}
334 />
335 <CategoryRow
336 categoryKey="dependencies"
337 score={scoreRow.dependenciesScore}
338 issues={scoreRow.issues}
339 gradeStr={scoreRow.grade}
340 />
341 <CategoryRow
342 categoryKey="code_quality"
343 score={scoreRow.codeQualityScore}
344 issues={scoreRow.issues}
345 gradeStr={scoreRow.grade}
346 />
347 </div>
348 </div>
349
350 {/* Badge copy */}
351 <div style="margin-top: 20px; padding-top: 16px; border-top: 1px solid var(--border)">
352 <button
353 type="button"
354 class="btn btn-sm"
355 onclick={`navigator.clipboard.writeText(${JSON.stringify(badgeMarkdown)}).then(function(){var b=this;b.textContent='Copied!';setTimeout(function(){b.textContent='Copy badge markdown'},1500)}.bind(this)).catch(function(){alert('Copy failed')})`}
356 >
357 Copy badge markdown
358 </button>
359 </div>
360 </div>
361
362 {/* ── Issues section ────────────────────────────────── */}
363 {scoreRow.issues.length > 0 && (
364 <div
365 style="background: var(--bg-secondary); border: 1px solid var(--border); border-radius: var(--radius); padding: 20px; margin-bottom: 24px"
366 >
367 <h3
368 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; padding-bottom: 8px; border-bottom: 1px solid var(--border)"
369 >
370 Issues Found
371 </h3>
372 {scoreRow.issues.map((issue) => (
373 <div
374 style={`display: flex; align-items: flex-start; gap: 10px; padding: 8px 0; border-bottom: 1px solid var(--border); font-size: 14px`}
375 >
376 <span style="flex-shrink: 0; font-size: 16px">
377 {severityDot(issue.severity)}
378 </span>
379 <span
380 class="badge"
381 style={`flex-shrink: 0; font-size: 11px; color: ${severityColor(issue.severity)}; border-color: ${severityColor(issue.severity)}; text-transform: uppercase; padding: 1px 6px`}
382 >
383 {issue.severity}
384 </span>
385 <span style="color: var(--text)">
386 {issue.message}
387 </span>
388 </div>
389 ))}
390 </div>
391 )}
392
393 {/* ── Recommendations section ────────────────────────── */}
394 {scoreRow.recommendations.length > 0 && (
395 <div
396 style="background: var(--bg-secondary); border: 1px solid var(--border); border-radius: var(--radius); padding: 20px; margin-bottom: 24px"
397 >
398 <h3
399 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; padding-bottom: 8px; border-bottom: 1px solid var(--border)"
400 >
401 How to improve your score
402 </h3>
403 {scoreRow.recommendations.map((rec) => (
404 <div
405 style="display: flex; align-items: flex-start; gap: 10px; padding: 8px 0; border-bottom: 1px solid var(--border); font-size: 14px"
406 >
407 <span style="flex-shrink: 0; color: var(--text-muted)">
408 &#x2191;
409 </span>
410 <span
411 class="badge"
412 style={`flex-shrink: 0; font-size: 11px; color: ${priorityColor(rec.priority)}; border-color: ${priorityColor(rec.priority)}; text-transform: uppercase; padding: 1px 6px`}
413 >
414 {priorityLabel(rec.priority)}
415 </span>
416 <span style="color: var(--text)">
417 {rec.message}
418 </span>
419 </div>
420 ))}
421 </div>
422 )}
423
424 {/* ── Share your badge ──────────────────────────────── */}
425 <div
426 style="background: var(--bg-secondary); border: 1px solid var(--border); border-radius: var(--radius); padding: 20px; margin-bottom: 24px"
427 >
428 <h3
429 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; padding-bottom: 8px; border-bottom: 1px solid var(--border)"
430 >
431 Share your health badge
432 </h3>
433
434 <div style="margin-bottom: 12px">
435 <img
436 src={badgeUrl}
437 alt={`Gluecron Health: ${scoreRow.grade}`}
438 style="height: 20px; display: inline-block; vertical-align: middle"
439 />
440 </div>
441
442 <div
443 style="background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius); padding: 10px 12px; font-family: var(--font-mono); font-size: 12px; color: var(--text-muted); word-break: break-all; margin-bottom: 12px"
444 >
445 {badgeMarkdown}
446 </div>
447
448 <div style="display: flex; gap: 8px; flex-wrap: wrap">
449 <button
450 type="button"
451 class="btn btn-sm"
452 onclick={`navigator.clipboard.writeText(${JSON.stringify(badgeMarkdown)}).then(function(){var b=this;b.textContent='Copied!';setTimeout(function(){b.textContent='Copy markdown'},1500)}.bind(this)).catch(function(){alert('Copy failed')})`}
453 >
454 Copy markdown
455 </button>
456 <button
457 type="button"
458 class="btn btn-sm"
459 onclick={`navigator.clipboard.writeText(${JSON.stringify(badgeUrl)}).then(function(){var b=this;b.textContent='Copied!';setTimeout(function(){b.textContent='Copy URL'},1500)}.bind(this)).catch(function(){alert('Copy failed')})`}
460 >
461 Copy URL
462 </button>
463 </div>
464 </div>
465
466 {/* ── Score history ─────────────────────────────────── */}
467 {history.length > 1 && (
468 <div
469 style="background: var(--bg-secondary); border: 1px solid var(--border); border-radius: var(--radius); padding: 20px; margin-bottom: 24px"
470 >
471 <h3
472 style="font-size: 16px; font-weight: 600; margin-bottom: 12px; padding-bottom: 8px; border-bottom: 1px solid var(--border)"
473 >
474 Score history
475 </h3>
476 <table style="width: 100%; border-collapse: collapse; font-size: 14px">
477 <thead>
478 <tr style="color: var(--text-muted); font-size: 12px; border-bottom: 1px solid var(--border)">
479 <th style="text-align: left; padding: 4px 8px; font-weight: 500">Date</th>
480 <th style="text-align: left; padding: 4px 8px; font-weight: 500">Grade</th>
481 <th style="text-align: right; padding: 4px 8px; font-weight: 500">Score</th>
482 </tr>
483 </thead>
484 <tbody>
485 {history.map((row, i) => (
486 <tr
487 style={`border-bottom: 1px solid var(--border); ${i === 0 ? "font-weight: 600" : ""}`}
488 >
489 <td style="padding: 6px 8px; color: var(--text-muted)">
490 {formatDate(new Date(row.computedAt))}
491 </td>
492 <td style={`padding: 6px 8px; font-weight: 700; color: ${gradeColor(row.grade)}`}>
493 {row.grade}
494 </td>
495 <td style="padding: 6px 8px; text-align: right; color: var(--text)">
496 {row.score}
497 </td>
498 </tr>
499 ))}
500 </tbody>
501 </table>
502 </div>
503 )}
504 </>
505 )}
506 </Layout>
507 );
508 }
509);
510
511// ---------------------------------------------------------------------------
512// POST /:owner/:repo/health/compute — trigger recompute (owner only)
513// ---------------------------------------------------------------------------
514
515health.post(
516 "/:owner/:repo/health/compute",
517 softAuth,
518 requireAuth,
519 requireRepoAccess("admin"),
520 async (c) => {
521 const { owner: ownerName, repo: repoName } = c.req.param();
522 const user = c.get("user")!;
523
524 const resolved = await resolveRepo(ownerName, repoName);
525 if (!resolved) return c.notFound();
526
527 // Only the repo owner may trigger a manual recompute
528 if (user.id !== resolved.owner.id) {
529 return c.redirect(`/${ownerName}/${repoName}/health`);
530 }
531
532 // Run synchronously so the redirect shows fresh data
533 try {
534 await computeAndStoreHealthScore(resolved.repo.id, ownerName, repoName);
535 } catch (err) {
536 console.error("[health/compute] failed:", err);
537 }
538
539 return c.redirect(`/${ownerName}/${repoName}/health`);
540 }
541);
287542
288543export default health;
Modifiedsrc/views/components.tsx+9−1View fileUnifiedSplit
106106 | "projects"
107107 | "settings"
108108 | "ask"
109 | "spec";
109 | "spec"
110 | "health";
110111}> = ({ owner, repo, active }) => (
111112 <div class="repo-nav">
112113 <a href={`/${owner}/${repo}`} class={active === "code" ? "active" : ""}>
166167 >
167168 Insights
168169 </a>
170 <a
171 href={`/${owner}/${repo}/health`}
172 class={active === "health" ? "active" : ""}
173 title="Code Health Score"
174 >
175 {"⬡"} Health
176 </a>
169177 <a
170178 href={`/${owner}/${repo}/explain`}
171179 class={active === "explain" ? "active" : ""}
172180