@monoes/monograph 1.0.0 → 1.2.0

package/src/export/markdown.ts

@@ -0,0 +1,290 @@
+import { relative } from 'path';
+import type { MonographDb } from '../storage/db.js';
+
+export interface MarkdownReportOptions {
+  groupByOwner?: boolean;
+  repoRoot?: string;
+  title?: string;
+}
+
+function relPath(filePath: string, repoRoot?: string): string {
+  if (!repoRoot) return filePath;
+  return relative(repoRoot, filePath);
+}
+
+function backtick(p: string): string {
+  return `\`${p}\``;
+}
+
+interface FileRow {
+  name: string;
+  file_path: string;
+  owner?: string | null;
+  line?: number;
+  in_degree?: number;
+}
+
+interface DupeRow {
+  src_path: string;
+  target_path: string;
+  owner?: string | null;
+}
+
+interface ViolationRow {
+  file_path: string;
+  line: number;
+  rule: string;
+  owner?: string | null;
+}
+
+function getOwner(row: { owner?: string | null }): string {
+  return row.owner?.trim() || 'Unowned';
+}
+
+function groupBy<T>(items: T[], keyFn: (item: T) => string): Map<string, T[]> {
+  const map = new Map<string, T[]>();
+  for (const item of items) {
+    const k = keyFn(item);
+    if (!map.has(k)) map.set(k, []);
+    map.get(k)!.push(item);
+  }
+  return map;
+}
+
+/**
+ * Generate a human-readable Markdown report from the monograph graph DB.
+ */
+export function exportMarkdown(db: MonographDb, options?: MarkdownReportOptions): string {
+  const { groupByOwner = false, repoRoot, title = 'Monograph Report' } = options ?? {};
+  const sections: string[] = [];
+
+  sections.push(`## ${title}`);
+  sections.push('');
+
+  // ── Health Score ───────────────────────────────────────────────────────────
+  const healthRow = db.prepare(`
+    SELECT json_extract(properties, '$.healthScore') AS score,
+           json_extract(properties, '$.healthGrade') AS grade
+    FROM nodes
+    WHERE json_extract(properties, '$.healthScore') IS NOT NULL
+    LIMIT 1
+  `).get() as { score: number; grade: string } | undefined;
+
+  if (healthRow) {
+    sections.push('### Health Score');
+    sections.push('');
+    const gradeStr = healthRow.grade ? ` (Grade: **${healthRow.grade}**)` : '';
+    sections.push(`Score: **${healthRow.score}**${gradeStr}`);
+    sections.push('');
+  }
+
+  // ── Unreachable files ──────────────────────────────────────────────────────
+  const unreachable = db.prepare(`
+    SELECT name, file_path,
+           json_extract(properties, '$.owner') AS owner
+    FROM nodes
+    WHERE label = 'File'
+    AND (
+      json_extract(properties, '$.reachabilityRole') = 'unreachable'
+      OR properties LIKE '%"unreachable"%'
+    )
+    AND file_path IS NOT NULL
+    ORDER BY file_path
+  `).all() as FileRow[];
+
+  if (unreachable.length > 0) {
+    if (groupByOwner) {
+      const byOwner = groupBy(unreachable, getOwner);
+      for (const [owner, rows] of byOwner) {
+        sections.push(`### Unreachable Files — ${owner} (${rows.length})`);
+        sections.push('');
+        for (const row of rows) {
+          sections.push(`- ${backtick(relPath(row.file_path, repoRoot))}`);
+        }
+        sections.push('');
+      }
+    } else {
+      sections.push(`### Unreachable Files (${unreachable.length})`);
+      sections.push('');
+      for (const row of unreachable) {
+        sections.push(`- ${backtick(relPath(row.file_path, repoRoot))}`);
+      }
+      sections.push('');
+    }
+  }
+
+  // ── God nodes ──────────────────────────────────────────────────────────────
+  const totalNodes = (db.prepare(`SELECT COUNT(*) as c FROM nodes WHERE label = 'File'`).get() as { c: number }).c;
+  const top10pct = Math.max(1, Math.floor(totalNodes * 0.1));
+  const godNodes = db.prepare(`
+    SELECT n.name, n.file_path,
+           COALESCE(n.start_line, 1) AS line,
+           json_extract(n.properties, '$.owner') AS owner,
+           COUNT(e.id) AS in_degree
+    FROM nodes n
+    LEFT JOIN edges e ON e.target_id = n.id
+    WHERE n.file_path IS NOT NULL AND n.label = 'File'
+    GROUP BY n.id
+    ORDER BY in_degree DESC
+    LIMIT ?
+  `).all(top10pct) as FileRow[];
+
+  const filteredGodNodes = godNodes.filter(r => (r.in_degree ?? 0) > 0);
+  if (filteredGodNodes.length > 0) {
+    if (groupByOwner) {
+      const byOwner = groupBy(filteredGodNodes, getOwner);
+      for (const [owner, rows] of byOwner) {
+        sections.push(`### God Nodes — ${owner} (${rows.length})`);
+        sections.push('');
+        sections.push('| File | Fan-in |');
+        sections.push('|------|--------|');
+        for (const row of rows) {
+          sections.push(`| ${backtick(relPath(row.file_path, repoRoot))} | ${row.in_degree} |`);
+        }
+        sections.push('');
+      }
+    } else {
+      sections.push(`### God Nodes (${filteredGodNodes.length})`);
+      sections.push('');
+      sections.push('| File | Fan-in |');
+      sections.push('|------|--------|');
+      for (const row of filteredGodNodes) {
+        sections.push(`| ${backtick(relPath(row.file_path, repoRoot))} | ${row.in_degree} |`);
+      }
+      sections.push('');
+    }
+  }
+
+  // ── Duplicate files ────────────────────────────────────────────────────────
+  const dupes = db.prepare(`
+    SELECT n1.file_path AS src_path,
+           n2.file_path AS target_path,
+           json_extract(n1.properties, '$.owner') AS owner
+    FROM edges e
+    JOIN nodes n1 ON n1.id = e.source_id
+    JOIN nodes n2 ON n2.id = e.target_id
+    WHERE e.relation = 'STRUCTURALLY_SIMILAR'
+    AND n1.file_path IS NOT NULL AND n2.file_path IS NOT NULL
+    ORDER BY n1.file_path
+  `).all() as DupeRow[];
+
+  if (dupes.length > 0) {
+    if (groupByOwner) {
+      const byOwner = groupBy(dupes, getOwner);
+      for (const [owner, rows] of byOwner) {
+        sections.push(`### Duplicate Files — ${owner} (${rows.length})`);
+        sections.push('');
+        for (const row of rows) {
+          sections.push(`- ${backtick(relPath(row.src_path, repoRoot))} ↔ ${backtick(relPath(row.target_path, repoRoot))}`);
+        }
+        sections.push('');
+      }
+    } else {
+      sections.push(`### Duplicate Files (${dupes.length})`);
+      sections.push('');
+      for (const row of dupes) {
+        sections.push(`- ${backtick(relPath(row.src_path, repoRoot))} ↔ ${backtick(relPath(row.target_path, repoRoot))}`);
+      }
+      sections.push('');
+    }
+  }
+
+  // ── Boundary violations ───────────────────────────────────────────────────
+  const violations = db.prepare(`
+    SELECT file_path, COALESCE(start_line, 1) AS line,
+           json_extract(properties, '$.boundaryViolation') AS rule,
+           json_extract(properties, '$.owner') AS owner
+    FROM nodes
+    WHERE file_path IS NOT NULL
+    AND json_extract(properties, '$.boundaryViolation') IS NOT NULL
+    ORDER BY file_path
+  `).all() as ViolationRow[];
+
+  if (violations.length > 0) {
+    if (groupByOwner) {
+      const byOwner = groupBy(violations, getOwner);
+      for (const [owner, rows] of byOwner) {
+        sections.push(`### Boundary Violations — ${owner} (${rows.length})`);
+        sections.push('');
+        for (const row of rows) {
+          sections.push(`- ${backtick(relPath(row.file_path, repoRoot))}:${row.line} — ${row.rule}`);
+        }
+        sections.push('');
+      }
+    } else {
+      sections.push(`### Boundary Violations (${violations.length})`);
+      sections.push('');
+      for (const row of violations) {
+        sections.push(`- ${backtick(relPath(row.file_path, repoRoot))}:${row.line} — ${row.rule}`);
+      }
+      sections.push('');
+    }
+  }
+
+  // ── Suggestions (top 3 from DB if available) ──────────────────────────────
+  let suggestionRows: { suggestion: string }[] = [];
+  try {
+    suggestionRows = db.prepare(`
+      SELECT json_extract(properties, '$.suggestion') AS suggestion
+      FROM nodes
+      WHERE json_extract(properties, '$.suggestion') IS NOT NULL
+      LIMIT 3
+    `).all() as { suggestion: string }[];
+  } catch {
+    // table or column not present — skip
+  }
+
+  if (suggestionRows.length > 0) {
+    sections.push('### Suggestions');
+    sections.push('');
+    for (const row of suggestionRows) {
+      sections.push(`- ${row.suggestion}`);
+    }
+    sections.push('');
+  }
+
+  return sections.join('\n');
+}
+
+// ── Round 10: health + duplication Markdown exports ───────────────────────────
+
+export interface MarkdownHealthFinding {
+  filePath: string;
+  functionName: string;
+  startLine: number;
+  cyclomatic: number;
+  cognitive: number;
+  crapScore: number;
+  severity: string;
+}
+
+export interface MarkdownDuplicationGroup {
+  groupId: number;
+  instances: Array<{ filePath: string; startLine: number; endLine: number }>;
+  duplicatedLines: number;
+}
+
+export function exportHealthMarkdown(findings: MarkdownHealthFinding[], title = 'Health Report'): string {
+  const lines = [`# ${title}`, '', `Found ${findings.length} complex function(s).`, ''];
+  if (findings.length === 0) return lines.join('\n');
+  lines.push('| File | Function | Line | Cyclomatic | Cognitive | CRAP | Severity |');
+  lines.push('|------|----------|------|------------|-----------|------|----------|');
+  for (const f of findings) {
+    const file = f.filePath.split('/').slice(-2).join('/');
+    lines.push(`| ${file} | \`${f.functionName}\` | ${f.startLine} | ${f.cyclomatic} | ${f.cognitive} | ${f.crapScore.toFixed(1)} | ${f.severity} |`);
+  }
+  return lines.join('\n');
+}
+
+export function exportDuplicationMarkdown(groups: MarkdownDuplicationGroup[], title = 'Duplication Report'): string {
+  const lines = [`# ${title}`, '', `Found ${groups.length} clone group(s).`, ''];
+  for (const g of groups) {
+    lines.push(`## Group ${g.groupId} — ${g.duplicatedLines} lines`);
+    for (const inst of g.instances) {
+      const file = inst.filePath.split('/').slice(-2).join('/');
+      lines.push(`- \`${file}\` lines ${inst.startLine}–${inst.endLine}`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}

package/src/export/mermaid.ts

@@ -0,0 +1,100 @@
+import type { MonographNode, MonographEdge } from '../types.js';
+
+const MAX_NODES = 200;
+
+/**
+ * Sanitize a string for use as a Mermaid node label (inside quotes).
+ * Strips characters that break Mermaid syntax.
+ */
+function sanitizeLabel(s: string): string {
+  return s
+    .replace(/["<>&{}()[\]|]/g, '')
+    .substring(0, 40)
+    .trim();
+}
+
+/**
+ * Make a Mermaid-safe node id from an arbitrary string.
+ */
+function safeId(id: string): string {
+  return id.replace(/[^a-zA-Z0-9_]/g, '_');
+}
+
+/**
+ * Converts a knowledge graph to Mermaid flowchart syntax.
+ *
+ * - Nodes are grouped into subgraphs by communityId when present.
+ * - Edges use `-->` for EXTRACTED confidence and `-.->` for INFERRED/AMBIGUOUS.
+ * - Edge labels show the relation type.
+ * - Diagram is capped at 200 nodes to avoid extremely large output.
+ */
+export function toMermaid(nodes: MonographNode[], edges: MonographEdge[]): string {
+  const capped = nodes.slice(0, MAX_NODES);
+  const cappedIds = new Set(capped.map(n => n.id));
+
+  const lines: string[] = ['graph TD'];
+
+  // Group by community
+  const communities = new Map<number | undefined, MonographNode[]>();
+  for (const n of capped) {
+    const key = n.communityId;
+    const group = communities.get(key) ?? [];
+    group.push(n);
+    communities.set(key, group);
+  }
+
+  const hasCommunities = communities.has(undefined)
+    ? communities.size > 1
+    : communities.size > 0;
+
+  if (hasCommunities && !communities.has(undefined)) {
+    // All nodes have communityId — use subgraphs
+    for (const [communityId, members] of communities) {
+      lines.push(`  subgraph community_${communityId}["Community ${communityId}"]`);
+      for (const n of members) {
+        const nid = safeId(n.id);
+        const label = sanitizeLabel(n.name);
+        lines.push(`    ${nid}["${label}<br/>${n.label}"]`);
+      }
+      lines.push('  end');
+    }
+  } else if (hasCommunities) {
+    // Mix of nodes with and without communityId
+    // Emit subgraphs for communities, then ungrouped
+    for (const [communityId, members] of communities) {
+      if (communityId === undefined) continue;
+      lines.push(`  subgraph community_${communityId}["Community ${communityId}"]`);
+      for (const n of members) {
+        const nid = safeId(n.id);
+        const label = sanitizeLabel(n.name);
+        lines.push(`    ${nid}["${label}<br/>${n.label}"]`);
+      }
+      lines.push('  end');
+    }
+    // ungrouped nodes
+    for (const n of communities.get(undefined) ?? []) {
+      const nid = safeId(n.id);
+      const label = sanitizeLabel(n.name);
+      lines.push(`  ${nid}["${label}<br/>${n.label}"]`);
+    }
+  } else {
+    // No communities — flat layout
+    for (const n of capped) {
+      const nid = safeId(n.id);
+      const label = sanitizeLabel(n.name);
+      lines.push(`  ${nid}["${label}<br/>${n.label}"]`);
+    }
+  }
+
+  // Edges — only between nodes in the capped set
+  for (const e of edges) {
+    if (!cappedIds.has(e.sourceId) || !cappedIds.has(e.targetId)) continue;
+    const src = safeId(e.sourceId);
+    const tgt = safeId(e.targetId);
+    const arrow = e.confidence === 'EXTRACTED' ? '-->' : '-..->';
+    const label = sanitizeLabel(e.relation);
+    lines.push(`  ${src} ${arrow}|${label}| ${tgt}`);
+  }
+
+  return lines.join('\n');
+}

package/src/export/sarif.ts

@@ -0,0 +1,236 @@
+import type Database from 'better-sqlite3';
+import { createHash } from 'crypto';
+import { relative } from 'path';
+
+export interface SarifRule {
+  id: string;
+  name: string;
+  shortDescription: { text: string };
+  fullDescription: { text: string };
+  helpUri?: string;
+}
+
+export interface SarifResult {
+  ruleId: string;
+  level: 'error' | 'warning' | 'note';
+  message: { text: string };
+  locations: Array<{
+    physicalLocation: {
+      artifactLocation: { uri: string };
+      region?: { startLine: number };
+    };
+  }>;
+  fingerprints?: { 'monograph/v1': string };
+}
+
+export interface SarifDocument {
+  $schema: string;
+  version: '2.1.0';
+  runs: [{
+    tool: { driver: { name: string; version: string; rules: SarifRule[] } };
+    results: SarifResult[];
+  }];
+}
+
+const SARIF_RULES: SarifRule[] = [
+  {
+    id: 'monograph/god-node',
+    name: 'GodNode',
+    shortDescription: { text: 'High-centrality node (god node) exceeds fan-in threshold' },
+    fullDescription: { text: 'A file or module has an unusually high number of incoming dependencies, making it a central point of coupling. Consider splitting this module into smaller, more focused units.' },
+    helpUri: 'https://github.com/nokhodian/monomind/blob/main/docs/rules/god-node.md',
+  },
+  {
+    id: 'monograph/unreachable-file',
+    name: 'UnreachableFile',
+    shortDescription: { text: 'File node unreachable from any entry point' },
+    fullDescription: { text: 'A file is not reachable from any known entry point. It may be dead code that can be safely removed.' },
+    helpUri: 'https://github.com/nokhodian/monomind/blob/main/docs/rules/unreachable-file.md',
+  },
+  {
+    id: 'monograph/circular-import',
+    name: 'CircularImport',
+    shortDescription: { text: 'Circular import detected' },
+    fullDescription: { text: 'A circular import chain was detected between files. Circular imports can cause initialization order issues and make the codebase harder to understand.' },
+    helpUri: 'https://github.com/nokhodian/monomind/blob/main/docs/rules/circular-import.md',
+  },
+  {
+    id: 'monograph/bridge-node',
+    name: 'BridgeNode',
+    shortDescription: { text: 'Bridge node — high cross-community coupling' },
+    fullDescription: { text: 'A file acts as a bridge between multiple community clusters, creating high cross-community coupling. This may indicate architectural boundaries are not being respected.' },
+    helpUri: 'https://github.com/nokhodian/monomind/blob/main/docs/rules/bridge-node.md',
+  },
+  {
+    id: 'monograph/hotspot',
+    name: 'Hotspot',
+    shortDescription: { text: 'File is both frequently changed and highly connected' },
+    fullDescription: { text: 'A file is both a churn hotspot (frequently modified) and highly connected in the dependency graph. Changes here have wide blast radius and high risk of regression.' },
+    helpUri: 'https://github.com/nokhodian/monomind/blob/main/docs/rules/hotspot.md',
+  },
+];
+
+// Map ruleId to SARIF level
+const RULE_LEVELS: Record<string, 'error' | 'warning' | 'note'> = {
+  'monograph/god-node': 'warning',
+  'monograph/unreachable-file': 'note',
+  'monograph/circular-import': 'error',
+  'monograph/bridge-node': 'warning',
+  'monograph/hotspot': 'warning',
+};
+
+function fingerprint(ruleId: string, filePath: string): string {
+  return createHash('sha256').update(`${ruleId}:${filePath}`).digest('hex');
+}
+
+function toFileUri(repoRoot: string, filePath: string): string {
+  const rel = relative(repoRoot, filePath);
+  return `file:///${rel.replace(/\\/g, '/')}`;
+}
+
+function makeResult(
+  ruleId: string,
+  message: string,
+  filePath: string,
+  startLine: number | null | undefined,
+  repoRoot: string,
+): SarifResult {
+  const result: SarifResult = {
+    ruleId,
+    level: RULE_LEVELS[ruleId] ?? 'warning',
+    message: { text: message },
+    locations: [
+      {
+        physicalLocation: {
+          artifactLocation: { uri: toFileUri(repoRoot, filePath) },
+          ...(startLine != null ? { region: { startLine } } : {}),
+        },
+      },
+    ],
+    fingerprints: { 'monograph/v1': fingerprint(ruleId, filePath) },
+  };
+  return result;
+}
+
+export function exportSarif(db: Database.Database, repoRoot: string): SarifDocument {
+  const results: SarifResult[] = [];
+
+  // ── God nodes (top 10% by fan-in) ────────────────────────────────────────────
+  const totalNodes = (db.prepare(`SELECT COUNT(*) as c FROM nodes WHERE label = 'File'`).get() as { c: number }).c;
+  const top10pct = Math.max(1, Math.floor(totalNodes * 0.1));
+  const godNodes = db.prepare(`
+    SELECT n.id, n.name, n.file_path, n.start_line,
+           COUNT(e.id) AS in_degree
+    FROM nodes n
+    LEFT JOIN edges e ON e.target_id = n.id
+    WHERE n.file_path IS NOT NULL AND n.label = 'File'
+    GROUP BY n.id
+    ORDER BY in_degree DESC
+    LIMIT ?
+  `).all(top10pct) as { id: string; name: string; file_path: string; start_line: number | null; in_degree: number }[];
+
+  for (const row of godNodes) {
+    if (row.in_degree === 0) continue;
+    results.push(makeResult(
+      'monograph/god-node',
+      `God node: "${row.name}" has ${row.in_degree} incoming dependencies (fan-in).`,
+      row.file_path,
+      row.start_line,
+      repoRoot,
+    ));
+  }
+
+  // ── Unreachable files ─────────────────────────────────────────────────────────
+  const unreachable = db.prepare(`
+    SELECT id, name, file_path FROM nodes
+    WHERE label = 'File'
+    AND (
+      json_extract(properties, '$.reachabilityRole') = 'unreachable'
+      OR properties LIKE '%"unreachable"%'
+    )
+    AND file_path IS NOT NULL
+  `).all() as { id: string; name: string; file_path: string }[];
+
+  for (const row of unreachable) {
+    results.push(makeResult(
+      'monograph/unreachable-file',
+      `Unreachable file: "${row.name}" is not reachable from any entry point.`,
+      row.file_path,
+      null,
+      repoRoot,
+    ));
+  }
+
+  // ── Hotspots (churnScore > 0.5) ───────────────────────────────────────────────
+  const hotspots = db.prepare(`
+    SELECT id, name, file_path, start_line
+    FROM nodes
+    WHERE file_path IS NOT NULL
+    AND json_extract(properties, '$.churnScore') > 0.5
+  `).all() as { id: string; name: string; file_path: string; start_line: number | null }[];
+
+  for (const row of hotspots) {
+    results.push(makeResult(
+      'monograph/hotspot',
+      `Hotspot: "${row.name}" has high churn score (>0.5) and is highly connected.`,
+      row.file_path,
+      row.start_line,
+      repoRoot,
+    ));
+  }
+
+  return {
+    $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+    version: '2.1.0',
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: 'monograph',
+            version: '1.1.0',
+            rules: SARIF_RULES,
+          },
+        },
+        results,
+      },
+    ],
+  };
+}
+
+// ── Round 10: health SARIF export ─────────────────────────────────────────────
+
+export interface SarifHealthFinding {
+  filePath: string;
+  functionName: string;
+  startLine: number;
+  endLine: number;
+  ruleId: string;
+  message: string;
+  severity: 'error' | 'warning' | 'note';
+}
+
+export function exportHealthSarif(findings: SarifHealthFinding[], root?: string): SarifDocument {
+  const rules: SarifRule[] = [
+    { id: 'complexity/cyclomatic', name: 'High Cyclomatic Complexity', shortDescription: { text: 'Function exceeds cyclomatic complexity threshold' }, fullDescription: { text: 'Cyclomatic complexity indicates the number of linearly independent paths through a function.' } },
+    { id: 'complexity/cognitive', name: 'High Cognitive Complexity', shortDescription: { text: 'Function exceeds cognitive complexity threshold' }, fullDescription: { text: 'Cognitive complexity measures how difficult a function is to understand.' } },
+    { id: 'complexity/crap', name: 'High CRAP Score', shortDescription: { text: 'Function has a high CRAP score due to complexity and low coverage' }, fullDescription: { text: 'CRAP = cyclomatic^2 * (1 - coverage/100)^3 + cyclomatic' } },
+  ];
+
+  const results: SarifResult[] = findings.map(f => ({
+    ruleId: f.ruleId,
+    message: { text: f.message },
+    level: f.severity === 'error' ? 'error' : f.severity === 'warning' ? 'warning' : 'note',
+    locations: [{
+      physicalLocation: {
+        artifactLocation: { uri: root ? f.filePath.replace(root, '').replace(/^\//, '') : f.filePath },
+        region: { startLine: f.startLine, endLine: f.endLine },
+      },
+    }],
+  }));
+
+  return {
+    $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+    version: '2.1.0',
+    runs: [{ tool: { driver: { name: 'monograph-health', version: '1.0.0', rules } }, results }],
+  };
+}

package/src/export/svg.ts

@@ -15,13 +15,26 @@ export function toSvg(nodes: MonographNode[], edges: MonographEdge[]): string {
     })
     .join('\n');
 
+  const COMMUNITY_COLORS = [
+    '#3b82f6','#ef4444','#22c55e','#f59e0b','#8b5cf6',
+    '#ec4899','#14b8a6','#f97316','#06b6d4','#84cc16',
+  ];
+  const degree = new Map<string, number>();
+  for (const e of edges) {
+    degree.set(e.sourceId, (degree.get(e.sourceId) ?? 0) + 1);
+    degree.set(e.targetId, (degree.get(e.targetId) ?? 0) + 1);
+  }
+
   const nodeSvg = [...positions.entries()]
     .map(([id, pos]) => {
       const node = nodes.find(n => n.id === id);
       const label = node?.name ?? id;
+      const deg = degree.get(id) ?? 0;
+      const r = Math.max(4, Math.min(16, 4 + deg));
+      const color = COMMUNITY_COLORS[(node?.communityId ?? 0) % COMMUNITY_COLORS.length];
       return (
-        `<circle cx="${pos.x}" cy="${pos.y}" r="6" fill="#3b82f6" stroke="#1e293b" stroke-width="0.5"/>` +
-        `<text x="${pos.x + 8}" y="${pos.y + 4}" font-size="10" fill="#1e293b">${sanitizeLabel(label)}</text>`
+        `<circle cx="${pos.x}" cy="${pos.y}" r="${r}" fill="${color}" stroke="#1e293b" stroke-width="0.5" opacity="0.85"/>` +
+        `<text x="${pos.x + r + 2}" y="${pos.y + 4}" font-size="10" fill="#1e293b">${sanitizeLabel(label)}</text>`
       );
     })
     .join('\n');