@monoes/monograph 1.5.6 → 1.5.8

package/src/export/markdown.ts

@@ -1,290 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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/obsidian.ts

@@ -1,44 +0,0 @@
-import type { MonographNode, MonographEdge } from '../types.js';
-import { join } from 'path';
-import { writeFileSync, mkdirSync } from 'fs';
-
-export function toObsidian(nodes: MonographNode[], edges: MonographEdge[], outputDir: string): void {
-  mkdirSync(outputDir, { recursive: true });
-
-  const adjOut = new Map<string, string[]>();
-  for (const e of edges) {
-    const targets = adjOut.get(e.sourceId) ?? [];
-    targets.push(e.targetId);
-    adjOut.set(e.sourceId, targets);
-  }
-
-  const nodeMap = new Map(nodes.map(n => [n.id, n]));
-
-  for (const node of nodes) {
-    const links = (adjOut.get(node.id) ?? [])
-      .map(tid => nodeMap.get(tid)?.name)
-      .filter(Boolean)
-      .map(name => `- [[${name}]]`)
-      .join('\n');
-
-    const content = `---
-label: ${node.label}
-file: ${node.filePath ?? ''}
-exported: ${node.isExported}
-community: ${node.communityId ?? 'none'}
----
-
-# ${node.name}
-
-**Type:** ${node.label}
-**Language:** ${node.language ?? 'unknown'}
-
-## Outgoing links
-
-${links || '_none_'}
-`;
-
-    const filename = node.name.replace(/[<>:"/\\|?*]/g, '_');
-    writeFileSync(join(outputDir, `${filename}.md`), content);
-  }
-}

package/src/export/sarif.ts

@@ -1,245 +0,0 @@
-import type Database from 'better-sqlite3';
-import { createHash } from 'crypto';
-import { readFileSync } from 'fs';
-import { relative, dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const PKG_VERSION = (() => {
-  try {
-    return JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8')).version ?? '0.0.0';
-  } catch { return '0.0.0'; }
-})();
-
-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/monoes/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/monoes/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/monoes/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/monoes/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/monoes/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: PKG_VERSION, rules } }, results }],
-  };
-}