@ghcrawl/api-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PwrDrvr LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@ghcrawl/api-core",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "ghcrawl core library for GitHub sync, SQLite storage, embeddings, search, and clustering",
+  "author": "PwrDrvr LLC <harold@pwrdrvr.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/pwrdrvr/ghcrawl",
+  "bugs": {
+    "url": "https://github.com/pwrdrvr/ghcrawl/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pwrdrvr/ghcrawl.git"
+  },
+  "keywords": [
+    "ghcrawl",
+    "github",
+    "sqlite",
+    "openai",
+    "embeddings",
+    "clustering"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "dependencies": {
+    "@shutterstock/p-map-iterable": "^1.1.2",
+    "@octokit/plugin-retry": "^8.0.3",
+    "@octokit/plugin-throttling": "^11.0.1",
+    "octokit": "^5.0.3",
+    "better-sqlite3": "^12.2.0",
+    "dotenv": "^17.2.2",
+    "openai": "^5.20.3",
+    "zod": "^3.25.76",
+    "@ghcrawl/api-contract": "0.1.0"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx --test src/*.test.ts src/**/*.test.ts"
+  }
+}

package/src/api/server.test.ts

@@ -0,0 +1,296 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { clusterDetailResponseSchema, clusterSummariesResponseSchema, healthResponseSchema, neighborsResponseSchema } from '@ghcrawl/api-contract';
+
+import { createApiServer } from './server.js';
+import { GHCrawlService } from '../service.js';
+
+test('health endpoint returns contract payload', async () => {
+  const service = new GHCrawlService({
+    config: {
+      workspaceRoot: process.cwd(),
+      configDir: '/tmp/ghcrawl-test',
+      configPath: '/tmp/ghcrawl-test/config.json',
+      configFileExists: true,
+      dbPath: ':memory:',
+      dbPathSource: 'config',
+      apiPort: 5179,
+      secretProvider: 'plaintext',
+      githubTokenSource: 'none',
+      openaiApiKeySource: 'none',
+      summaryModel: 'gpt-5-mini',
+      embedModel: 'text-embedding-3-large',
+      embedBatchSize: 8,
+      embedConcurrency: 10,
+      embedMaxUnread: 20,
+      openSearchIndex: 'ghcrawl-threads',
+      tuiPreferences: {},
+    },
+    github: {
+      checkAuth: async () => undefined,
+      getRepo: async () => ({}),
+      listRepositoryIssues: async () => [],
+      getIssue: async () => ({}),
+      getPull: async () => ({}),
+      listIssueComments: async () => [],
+      listPullReviews: async () => [],
+      listPullReviewComments: async () => [],
+    },
+  });
+
+  const server = createApiServer(service);
+  try {
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    assert(address && typeof address === 'object');
+
+    const response = await fetch(`http://127.0.0.1:${address.port}/health`);
+    assert.equal(response.status, 200);
+    const payload = healthResponseSchema.parse((await response.json()) as unknown);
+
+    assert.equal(payload.ok, true);
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    service.close();
+  }
+});
+
+test('neighbors endpoint returns contract payload', async () => {
+  const service = new GHCrawlService({
+    config: {
+      workspaceRoot: process.cwd(),
+      configDir: '/tmp/ghcrawl-test',
+      configPath: '/tmp/ghcrawl-test/config.json',
+      configFileExists: true,
+      dbPath: ':memory:',
+      dbPathSource: 'config',
+      apiPort: 5179,
+      secretProvider: 'plaintext',
+      githubTokenSource: 'none',
+      openaiApiKeySource: 'none',
+      summaryModel: 'gpt-5-mini',
+      embedModel: 'text-embedding-3-large',
+      embedBatchSize: 8,
+      embedConcurrency: 10,
+      embedMaxUnread: 20,
+      openSearchIndex: 'ghcrawl-threads',
+      tuiPreferences: {},
+    },
+    github: {
+      checkAuth: async () => undefined,
+      getRepo: async () => ({}),
+      listRepositoryIssues: async () => [],
+      getIssue: async () => ({}),
+      getPull: async () => ({}),
+      listIssueComments: async () => [],
+      listPullReviews: async () => [],
+      listPullReviewComments: async () => [],
+    },
+  });
+
+  const now = '2026-03-09T00:00:00Z';
+  service.db
+    .prepare(
+      `insert into repositories (id, owner, name, full_name, github_repo_id, raw_json, updated_at)
+       values (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(1, 'openclaw', 'openclaw', 'openclaw/openclaw', '1', '{}', now);
+  service.db
+    .prepare(
+      `insert into threads (
+        id, repo_id, github_id, number, kind, state, title, body, author_login, author_type, html_url,
+        labels_json, assignees_json, raw_json, content_hash, is_draft, created_at_gh, updated_at_gh, closed_at_gh,
+        merged_at_gh, first_pulled_at, last_pulled_at, updated_at
+      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(10, 1, '100', 42, 'issue', 'open', 'Downloader hangs', 'The transfer never finishes.', 'alice', 'User', 'https://github.com/openclaw/openclaw/issues/42', '[]', '[]', '{}', 'hash-42', 0, now, now, null, null, now, now, now);
+  service.db
+    .prepare(
+      `insert into threads (
+        id, repo_id, github_id, number, kind, state, title, body, author_login, author_type, html_url,
+        labels_json, assignees_json, raw_json, content_hash, is_draft, created_at_gh, updated_at_gh, closed_at_gh,
+        merged_at_gh, first_pulled_at, last_pulled_at, updated_at
+      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(11, 1, '101', 43, 'pull_request', 'open', 'Fix downloader hang', 'Implements a fix.', 'bob', 'User', 'https://github.com/openclaw/openclaw/pull/43', '[]', '[]', '{}', 'hash-43', 0, now, now, null, null, now, now, now);
+  service.db
+    .prepare(
+      `insert into document_embeddings (thread_id, source_kind, model, dimensions, content_hash, embedding_json, created_at, updated_at)
+       values (?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(10, 'dedupe_summary', 'text-embedding-3-large', 2, 'hash-42', '[1,0]', now, now);
+  service.db
+    .prepare(
+      `insert into document_embeddings (thread_id, source_kind, model, dimensions, content_hash, embedding_json, created_at, updated_at)
+       values (?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(11, 'dedupe_summary', 'text-embedding-3-large', 2, 'hash-43', '[0.99,0.01]', now, now);
+
+  const server = createApiServer(service);
+  try {
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    assert(address && typeof address === 'object');
+
+    const response = await fetch(
+      `http://127.0.0.1:${address.port}/neighbors?owner=openclaw&repo=openclaw&number=42&limit=5&minScore=0.1`,
+    );
+    assert.equal(response.status, 200);
+    const payload = neighborsResponseSchema.parse((await response.json()) as unknown);
+
+    assert.equal(payload.thread.number, 42);
+    assert.equal(payload.neighbors.length, 1);
+    assert.equal(payload.neighbors[0].number, 43);
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    service.close();
+  }
+});
+
+test('server returns 400 for malformed request inputs', async () => {
+  const service = new GHCrawlService({
+    config: {
+      workspaceRoot: process.cwd(),
+      configDir: '/tmp/ghcrawl-test',
+      configPath: '/tmp/ghcrawl-test/config.json',
+      configFileExists: true,
+      dbPath: ':memory:',
+      dbPathSource: 'config',
+      apiPort: 5179,
+      secretProvider: 'plaintext',
+      githubTokenSource: 'none',
+      openaiApiKeySource: 'none',
+      summaryModel: 'gpt-5-mini',
+      embedModel: 'text-embedding-3-large',
+      embedBatchSize: 8,
+      embedConcurrency: 10,
+      embedMaxUnread: 20,
+      openSearchIndex: 'ghcrawl-threads',
+      tuiPreferences: {},
+    },
+    github: {
+      checkAuth: async () => undefined,
+      getRepo: async () => ({}),
+      listRepositoryIssues: async () => [],
+      getIssue: async () => ({}),
+      getPull: async () => ({}),
+      listIssueComments: async () => [],
+      listPullReviews: async () => [],
+      listPullReviewComments: async () => [],
+    },
+  });
+
+  const server = createApiServer(service);
+  try {
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    assert(address && typeof address === 'object');
+
+    const missingRepo = await fetch(`http://127.0.0.1:${address.port}/threads?owner=openclaw`);
+    assert.equal(missingRepo.status, 400);
+
+    const badJson = await fetch(`http://127.0.0.1:${address.port}/actions/rerun`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{"owner":"openclaw"',
+    });
+    assert.equal(badJson.status, 400);
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    service.close();
+  }
+});
+
+test('cluster summary and detail endpoints return contract payloads', async () => {
+  const service = new GHCrawlService({
+    config: {
+      workspaceRoot: process.cwd(),
+      configDir: '/tmp/ghcrawl-test',
+      configPath: '/tmp/ghcrawl-test/config.json',
+      configFileExists: true,
+      dbPath: ':memory:',
+      dbPathSource: 'config',
+      apiPort: 5179,
+      secretProvider: 'plaintext',
+      githubTokenSource: 'none',
+      openaiApiKeySource: 'none',
+      summaryModel: 'gpt-5-mini',
+      embedModel: 'text-embedding-3-large',
+      embedBatchSize: 8,
+      embedConcurrency: 10,
+      embedMaxUnread: 20,
+      openSearchIndex: 'ghcrawl-threads',
+      tuiPreferences: {},
+    },
+    github: {
+      checkAuth: async () => undefined,
+      getRepo: async () => ({}),
+      listRepositoryIssues: async () => [],
+      getIssue: async () => ({}),
+      getPull: async () => ({}),
+      listIssueComments: async () => [],
+      listPullReviews: async () => [],
+      listPullReviewComments: async () => [],
+    },
+  });
+
+  const now = '2026-03-09T00:00:00Z';
+  service.db
+    .prepare(
+      `insert into repositories (id, owner, name, full_name, github_repo_id, raw_json, updated_at)
+       values (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(1, 'openclaw', 'openclaw', 'openclaw/openclaw', '1', '{}', now);
+  service.db
+    .prepare(
+      `insert into threads (
+        id, repo_id, github_id, number, kind, state, title, body, author_login, author_type, html_url,
+        labels_json, assignees_json, raw_json, content_hash, is_draft, created_at_gh, updated_at_gh, closed_at_gh,
+        merged_at_gh, first_pulled_at, last_pulled_at, updated_at
+      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(10, 1, '100', 42, 'issue', 'open', 'Downloader hangs', 'The transfer never finishes.', 'alice', 'User', 'https://github.com/openclaw/openclaw/issues/42', '[]', '[]', '{}', 'hash-42', 0, now, now, null, null, now, now, now);
+  service.db
+    .prepare(
+      `insert into cluster_runs (id, repo_id, scope, status, started_at, finished_at) values (?, ?, ?, ?, ?, ?)`,
+    )
+    .run(1, 1, 'openclaw/openclaw', 'completed', now, now);
+  service.db
+    .prepare(
+      `insert into clusters (id, repo_id, cluster_run_id, representative_thread_id, member_count, created_at)
+       values (?, ?, ?, ?, ?, ?)`,
+    )
+    .run(100, 1, 1, 10, 1, now);
+  service.db
+    .prepare(
+      `insert into cluster_members (cluster_id, thread_id, score_to_representative, created_at)
+       values (?, ?, ?, ?)`,
+    )
+    .run(100, 10, null, now);
+
+  const server = createApiServer(service);
+  try {
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    assert(address && typeof address === 'object');
+
+    const summariesResponse = await fetch(
+      `http://127.0.0.1:${address.port}/cluster-summaries?owner=openclaw&repo=openclaw&minSize=0`,
+    );
+    assert.equal(summariesResponse.status, 200);
+    const summaries = clusterSummariesResponseSchema.parse((await summariesResponse.json()) as unknown);
+    assert.equal(summaries.clusters[0]?.clusterId, 100);
+
+    const detailResponse = await fetch(
+      `http://127.0.0.1:${address.port}/cluster-detail?owner=openclaw&repo=openclaw&clusterId=100&bodyChars=20`,
+    );
+    assert.equal(detailResponse.status, 200);
+    const detail = clusterDetailResponseSchema.parse((await detailResponse.json()) as unknown);
+    assert.equal(detail.cluster.clusterId, 100);
+    assert.equal(detail.members[0]?.thread.number, 42);
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    service.close();
+  }
+});

package/src/api/server.ts

@@ -0,0 +1,171 @@
+import http from 'node:http';
+
+import { actionRequestSchema, refreshRequestSchema } from '@ghcrawl/api-contract';
+import { ZodError } from 'zod';
+
+import { GHCrawlService, parseRepoParams } from '../service.js';
+
+function sendJson(res: http.ServerResponse, status: number, payload: unknown): void {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+  res.end(JSON.stringify(payload));
+}
+
+async function readBody(req: http.IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  if (chunks.length === 0) return null;
+  return JSON.parse(Buffer.concat(chunks).toString('utf8')) as unknown;
+}
+
+export function createApiServer(service: GHCrawlService): http.Server {
+  return http.createServer(async (req, res) => {
+    try {
+      if (!req.url || !req.method) {
+        sendJson(res, 400, { error: 'Missing request metadata' });
+        return;
+      }
+
+      const url = new URL(req.url, 'http://127.0.0.1');
+
+      if (req.method === 'GET' && url.pathname === '/health') {
+        sendJson(res, 200, service.init());
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/repositories') {
+        sendJson(res, 200, service.listRepositories());
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/threads') {
+        const params = parseRepoParams(url);
+        const kindParam = url.searchParams.get('kind');
+        const kind = kindParam === 'issue' || kindParam === 'pull_request' ? kindParam : undefined;
+        sendJson(res, 200, service.listThreads({ ...params, kind }));
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/search') {
+        const params = parseRepoParams(url);
+        const query = url.searchParams.get('query');
+        if (!query) {
+          sendJson(res, 400, { error: 'Missing query parameter' });
+          return;
+        }
+        const modeParam = url.searchParams.get('mode');
+        const mode = modeParam === 'keyword' || modeParam === 'semantic' || modeParam === 'hybrid' ? modeParam : undefined;
+        sendJson(res, 200, await service.searchRepository({ ...params, query, mode }));
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/neighbors') {
+        const params = parseRepoParams(url);
+        const numberValue = url.searchParams.get('number');
+        if (!numberValue) {
+          sendJson(res, 400, { error: 'Missing number parameter' });
+          return;
+        }
+        const threadNumber = Number(numberValue);
+        if (!Number.isInteger(threadNumber) || threadNumber <= 0) {
+          sendJson(res, 400, { error: 'Invalid number parameter' });
+          return;
+        }
+        const limitValue = url.searchParams.get('limit');
+        const minScoreValue = url.searchParams.get('minScore');
+        sendJson(
+          res,
+          200,
+          service.listNeighbors({
+            ...params,
+            threadNumber,
+            limit: limitValue ? Number(limitValue) : undefined,
+            minScore: minScoreValue ? Number(minScoreValue) : undefined,
+          }),
+        );
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/clusters') {
+        const params = parseRepoParams(url);
+        sendJson(res, 200, service.listClusters(params));
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/cluster-summaries') {
+        const params = parseRepoParams(url);
+        const sortParam = url.searchParams.get('sort');
+        const sort = sortParam === 'recent' || sortParam === 'size' ? sortParam : undefined;
+        const minSizeValue = url.searchParams.get('minSize');
+        const limitValue = url.searchParams.get('limit');
+        const search = url.searchParams.get('search') ?? undefined;
+        sendJson(
+          res,
+          200,
+          service.listClusterSummaries({
+            ...params,
+            minSize: minSizeValue ? Number(minSizeValue) : undefined,
+            limit: limitValue ? Number(limitValue) : undefined,
+            sort,
+            search,
+          }),
+        );
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/cluster-detail') {
+        const params = parseRepoParams(url);
+        const clusterIdValue = url.searchParams.get('clusterId');
+        if (!clusterIdValue) {
+          sendJson(res, 400, { error: 'Missing clusterId parameter' });
+          return;
+        }
+        const clusterId = Number(clusterIdValue);
+        if (!Number.isInteger(clusterId) || clusterId <= 0) {
+          sendJson(res, 400, { error: 'Invalid clusterId parameter' });
+          return;
+        }
+        const memberLimitValue = url.searchParams.get('memberLimit');
+        const bodyCharsValue = url.searchParams.get('bodyChars');
+        sendJson(
+          res,
+          200,
+          service.getClusterDetailDump({
+            ...params,
+            clusterId,
+            memberLimit: memberLimitValue ? Number(memberLimitValue) : undefined,
+            bodyChars: bodyCharsValue ? Number(bodyCharsValue) : undefined,
+          }),
+        );
+        return;
+      }
+
+      if (req.method === 'POST' && url.pathname === '/actions/rerun') {
+        const body = actionRequestSchema.parse(await readBody(req));
+        sendJson(res, 200, await service.rerunAction(body));
+        return;
+      }
+
+      if (req.method === 'POST' && url.pathname === '/actions/refresh') {
+        const body = refreshRequestSchema.parse(await readBody(req));
+        sendJson(res, 200, await service.refreshRepository(body));
+        return;
+      }
+
+      sendJson(res, 404, { error: 'Not found' });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      sendJson(res, isBadRequestError(error, message) ? 400 : 500, { error: message });
+    }
+  });
+}
+
+function isBadRequestError(error: unknown, message: string): boolean {
+  return (
+    error instanceof SyntaxError ||
+    error instanceof ZodError ||
+    message.startsWith('Missing ') ||
+    message.startsWith('Invalid ')
+  );
+}

package/src/cluster/build.test.ts

@@ -0,0 +1,18 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { buildClusters } from './build.js';
+
+test('buildClusters groups connected components', () => {
+  const clusters = buildClusters(
+    [
+      { threadId: 1, number: 10, title: 'a' },
+      { threadId: 2, number: 11, title: 'b' },
+      { threadId: 3, number: 12, title: 'c' },
+    ],
+    [{ leftThreadId: 1, rightThreadId: 2, score: 0.9 }],
+  );
+
+  assert.equal(clusters.length, 2);
+  assert.deepEqual(clusters[0]?.members, [1, 2]);
+});

package/src/cluster/build.ts

@@ -0,0 +1,74 @@
+export type SimilarityEdge = {
+  leftThreadId: number;
+  rightThreadId: number;
+  score: number;
+};
+
+type Node = {
+  threadId: number;
+  number: number;
+  title: string;
+};
+
+class UnionFind {
+  private readonly parent = new Map<number, number>();
+
+  add(value: number): void {
+    if (!this.parent.has(value)) this.parent.set(value, value);
+  }
+
+  find(value: number): number {
+    const parent = this.parent.get(value);
+    if (parent === undefined) {
+      this.parent.set(value, value);
+      return value;
+    }
+    if (parent === value) return value;
+    const root = this.find(parent);
+    this.parent.set(value, root);
+    return root;
+  }
+
+  union(left: number, right: number): void {
+    const leftRoot = this.find(left);
+    const rightRoot = this.find(right);
+    if (leftRoot !== rightRoot) {
+      this.parent.set(rightRoot, leftRoot);
+    }
+  }
+}
+
+export function buildClusters(nodes: Node[], edges: SimilarityEdge[]): Array<{ representativeThreadId: number; members: number[] }> {
+  const uf = new UnionFind();
+  for (const node of nodes) uf.add(node.threadId);
+  for (const edge of edges) uf.union(edge.leftThreadId, edge.rightThreadId);
+
+  const byRoot = new Map<number, number[]>();
+  for (const node of nodes) {
+    const root = uf.find(node.threadId);
+    const list = byRoot.get(root) ?? [];
+    list.push(node.threadId);
+    byRoot.set(root, list);
+  }
+
+  const edgeCounts = new Map<number, number>();
+  for (const edge of edges) {
+    edgeCounts.set(edge.leftThreadId, (edgeCounts.get(edge.leftThreadId) ?? 0) + 1);
+    edgeCounts.set(edge.rightThreadId, (edgeCounts.get(edge.rightThreadId) ?? 0) + 1);
+  }
+
+  const nodesById = new Map(nodes.map((node) => [node.threadId, node]));
+  return Array.from(byRoot.values())
+    .map((members) => {
+      const representative = [...members].sort((leftId, rightId) => {
+        const left = nodesById.get(leftId);
+        const right = nodesById.get(rightId);
+        const edgeDelta = (edgeCounts.get(rightId) ?? 0) - (edgeCounts.get(leftId) ?? 0);
+        if (edgeDelta !== 0) return edgeDelta;
+        if (!left || !right) return leftId - rightId;
+        return left.number - right.number;
+      })[0];
+      return { representativeThreadId: representative, members: members.sort((left, right) => left - right) };
+    })
+    .sort((left, right) => right.members.length - left.members.length);
+}