co-maintainer 0.4.0-beta.1

package/dist/src/services/webhook.js

@@ -0,0 +1,401 @@
+/** Webhook dispatch: installation bookkeeping and the skip/enqueue rules
+ * for pull_request events. HTTP parsing and HMAC live in server/webhook/. */
+import { enqueue } from "./jobs.js";
+import { deactivateRepo, deactivateReposForInstallation, getRepo, setInstallationId, } from "../store/repos.js";
+import { findFindingByPostedComment } from "../store/findings.js";
+import { createReplyRequestAndJob, findReplyByPostedComment, } from "../store/replies.js";
+import { latestPostedReview } from "../store/reviews.js";
+import { markInstallationRemoved, markInstallationSuspended, upsertInstallation, } from "../store/installations.js";
+export const REVIEW_DEBOUNCE_MS = 20_000;
+const PR_ACTIONS = new Set([
+    "opened",
+    "reopened",
+    "synchronize",
+    "ready_for_review",
+]);
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function asBool(value) {
+    return value === true;
+}
+function appSlug(payload) {
+    return asString(asRecord(payload.installation)?.app_slug);
+}
+function hasAppMention(body, slug) {
+    const candidates = [slug, "co-maintainer"].filter((value) => Boolean(value));
+    return candidates.some((candidate) => {
+        const escaped = candidate.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const suffix = candidate === "co-maintainer" ? "(?:-[a-z0-9-]+)?" : "";
+        return new RegExp(`(^|[^\\w-])@${escaped}${suffix}(?![\\w-])`, "i").test(body);
+    });
+}
+function isBot(user) {
+    if (!user)
+        return false;
+    if (asString(user.type) === "Bot")
+        return true;
+    const login = asString(user.login) ?? "";
+    return login.endsWith("[bot]");
+}
+export function maybeEnqueueReview(input) {
+    const row = getRepo(input.repo);
+    if (!row || row.active !== 1) {
+        return {
+            outcome: "skipped",
+            reason: "repo-not-active",
+            repo: input.repo,
+            prNumber: input.prNumber,
+        };
+    }
+    if (row.auto_review !== 1) {
+        return {
+            outcome: "skipped",
+            reason: "auto-review-off",
+            repo: input.repo,
+            prNumber: input.prNumber,
+        };
+    }
+    if (row.skip_drafts === 1 && input.draft) {
+        return {
+            outcome: "skipped",
+            reason: "draft",
+            repo: input.repo,
+            prNumber: input.prNumber,
+        };
+    }
+    if (row.skip_bots === 1 && input.bot) {
+        return {
+            outcome: "skipped",
+            reason: "bot-author",
+            repo: input.repo,
+            prNumber: input.prNumber,
+        };
+    }
+    if (!row.knowledge_built_at) {
+        return {
+            outcome: "skipped",
+            reason: "no-knowledge-yet",
+            repo: input.repo,
+            prNumber: input.prNumber,
+        };
+    }
+    if (input.changedFiles === 0) {
+        return {
+            outcome: "skipped",
+            reason: "no-code-changes",
+            repo: input.repo,
+            prNumber: input.prNumber,
+        };
+    }
+    if (input.maxDiffLines !== undefined &&
+        input.additions + input.deletions > input.maxDiffLines) {
+        return {
+            outcome: "skipped",
+            reason: "diff-too-large",
+            repo: input.repo,
+            prNumber: input.prNumber,
+        };
+    }
+    if ((input.trigger === "review" || input.trigger === "review-comment") &&
+        input.headSha) {
+        const last = latestPostedReview(input.repo, input.prNumber);
+        if (last && last.head_sha === input.headSha) {
+            return {
+                outcome: "skipped",
+                reason: "nothing-new-since-last-round",
+                repo: input.repo,
+                prNumber: input.prNumber,
+            };
+        }
+    }
+    const last = latestPostedReview(input.repo, input.prNumber);
+    const incremental = row.review_scope === "incremental" && Boolean(last?.head_sha);
+    const { id } = enqueue({
+        type: "review",
+        repo: input.repo,
+        prNumber: input.prNumber,
+        deliveryId: input.deliveryId,
+        debounceMs: REVIEW_DEBOUNCE_MS,
+        args: {
+            trigger: input.trigger,
+            scope: incremental ? "incremental" : "whole-pr",
+            sinceCommit: incremental ? last.head_sha : undefined,
+            round: last ? last.round + 1 : 1,
+        },
+    });
+    return {
+        outcome: "enqueued",
+        repo: input.repo,
+        prNumber: input.prNumber,
+        jobId: id,
+    };
+}
+function applyInstallation(payload) {
+    const installation = asRecord(payload.installation);
+    const id = asNumber(installation?.id);
+    if (id === undefined)
+        return { outcome: "ignored" };
+    const action = asString(payload.action);
+    const account = asRecord(installation?.account);
+    if (action === "created") {
+        upsertInstallation({
+            id,
+            account_login: asString(account?.login) ?? "",
+            account_type: asString(account?.type) ?? "User",
+            permissions: installation?.permissions ?? {},
+            events: Array.isArray(installation?.events)
+                ? installation.events.map(String)
+                : [],
+        });
+        return { outcome: "ignored", reason: "installation-created" };
+    }
+    if (action === "deleted") {
+        markInstallationRemoved(id);
+        deactivateReposForInstallation(id);
+        return { outcome: "ignored", reason: "installation-deleted" };
+    }
+    if (action === "suspend") {
+        markInstallationSuspended(id, true);
+        return { outcome: "ignored", reason: "installation-suspended" };
+    }
+    if (action === "unsuspend") {
+        markInstallationSuspended(id, false);
+        return { outcome: "ignored", reason: "installation-unsuspended" };
+    }
+    return { outcome: "ignored" };
+}
+function applyInstallationRepositories(payload) {
+    const action = asString(payload.action);
+    const installationId = asNumber(asRecord(payload.installation)?.id);
+    if (action === "added" && installationId !== undefined) {
+        const added = payload.repositories_added;
+        if (Array.isArray(added)) {
+            for (const item of added) {
+                const fullName = asString(asRecord(item)?.full_name);
+                if (fullName)
+                    setInstallationId(fullName, installationId);
+            }
+        }
+        return { outcome: "ignored", reason: "repositories-added" };
+    }
+    if (action === "removed") {
+        const removed = payload.repositories_removed;
+        if (Array.isArray(removed)) {
+            for (const item of removed) {
+                const fullName = asString(asRecord(item)?.full_name);
+                if (fullName)
+                    deactivateRepo(fullName);
+            }
+        }
+        return { outcome: "ignored", reason: "repositories-removed" };
+    }
+    return { outcome: "ignored", reason: "repositories-added" };
+}
+function pullRequestEvent(payload, deliveryId, maxDiffLines) {
+    const action = asString(payload.action) ?? "";
+    const pr = asRecord(payload.pull_request);
+    const repo = asString(asRecord(payload.repository)?.full_name);
+    const prNumber = asNumber(pr?.number) ?? asNumber(payload.number);
+    if (!PR_ACTIONS.has(action) || !repo || prNumber === undefined) {
+        return { outcome: "ignored", repo, prNumber };
+    }
+    const user = asRecord(pr?.user);
+    const installationId = asNumber(asRecord(payload.installation)?.id);
+    if (installationId !== undefined)
+        setInstallationId(repo, installationId);
+    return maybeEnqueueReview({
+        repo,
+        prNumber,
+        draft: asBool(pr?.draft),
+        bot: isBot(user),
+        additions: asNumber(pr?.additions) ?? 0,
+        deletions: asNumber(pr?.deletions) ?? 0,
+        changedFiles: asNumber(pr?.changed_files) ?? -1,
+        deliveryId,
+        trigger: action,
+        headSha: asString(asRecord(pr?.head)?.sha),
+        maxDiffLines,
+    });
+}
+function reviewWakeEvent(event, payload, deliveryId, maxDiffLines) {
+    const action = asString(payload.action) ?? "";
+    const allowed = event === "pull_request_review"
+        ? action === "submitted"
+        : action === "created";
+    const pr = asRecord(payload.pull_request);
+    const repo = asString(asRecord(payload.repository)?.full_name);
+    const prNumber = asNumber(pr?.number);
+    if (!allowed || !repo || prNumber === undefined) {
+        return { outcome: "ignored", repo, prNumber };
+    }
+    const actor = asRecord(event === "pull_request_review"
+        ? asRecord(payload.review)?.user
+        : asRecord(payload.comment)?.user);
+    if (isBot(actor)) {
+        return {
+            outcome: "skipped",
+            reason: "own-comment",
+            repo,
+            prNumber,
+        };
+    }
+    const installationId = asNumber(asRecord(payload.installation)?.id);
+    if (installationId !== undefined)
+        setInstallationId(repo, installationId);
+    return maybeEnqueueReview({
+        repo,
+        prNumber,
+        draft: asBool(pr?.draft),
+        bot: false,
+        additions: asNumber(pr?.additions) ?? 0,
+        deletions: asNumber(pr?.deletions) ?? 0,
+        changedFiles: asNumber(pr?.changed_files) ?? -1,
+        deliveryId,
+        trigger: event === "pull_request_review" ? "review" : "review-comment",
+        headSha: asString(asRecord(pr?.head)?.sha),
+        maxDiffLines,
+    });
+}
+function replyTarget(repo, prNumber, parentCommentId) {
+    if (findFindingByPostedComment(repo, prNumber, parentCommentId)) {
+        return parentCommentId;
+    }
+    return (findReplyByPostedComment(repo, prNumber, parentCommentId)
+        ?.target_comment_id ?? undefined);
+}
+function enqueueReply(payload, deliveryId, sourceKind, sourceCommentId, repo, prNumber, sourceBody, sourceAuthor, targetCommentId, sourcePath, sourceLine, sourceCommitId) {
+    const installationId = asNumber(asRecord(payload.installation)?.id);
+    if (installationId !== undefined)
+        setInstallationId(repo, installationId);
+    const row = getRepo(repo);
+    if (!row || row.active !== 1) {
+        return {
+            outcome: "skipped",
+            reason: "repo-not-active",
+            repo,
+            prNumber,
+        };
+    }
+    const result = createReplyRequestAndJob({
+        repo,
+        prNumber,
+        sourceKind,
+        sourceCommentId,
+        targetCommentId,
+        sourceBody: sourceBody.slice(0, 20_000),
+        sourceAuthor,
+        sourcePath,
+        sourceLine,
+        sourceCommitId,
+        deliveryId,
+    });
+    if (!result.created) {
+        return {
+            outcome: "skipped",
+            reason: "duplicate-reply",
+            repo,
+            prNumber,
+            jobId: result.request.job_id ?? undefined,
+        };
+    }
+    return {
+        outcome: "enqueued",
+        repo,
+        prNumber,
+        jobId: result.request.job_id ?? undefined,
+    };
+}
+function reviewCommentEvent(payload, deliveryId, maxDiffLines) {
+    const comment = asRecord(payload.comment);
+    const repo = asString(asRecord(payload.repository)?.full_name);
+    const pr = asRecord(payload.pull_request);
+    const prNumber = asNumber(pr?.number);
+    const action = asString(payload.action) ?? "";
+    const sourceId = comment?.id;
+    const parentId = comment?.in_reply_to_id;
+    const author = asRecord(comment?.user);
+    if (action !== "created" || !repo || prNumber === undefined) {
+        return { outcome: "ignored", repo, prNumber };
+    }
+    if (isBot(author)) {
+        return {
+            outcome: "skipped",
+            reason: "own-comment",
+            repo,
+            prNumber,
+        };
+    }
+    if ((typeof sourceId === "number" || typeof sourceId === "string") &&
+        (typeof parentId === "number" || typeof parentId === "string")) {
+        const target = replyTarget(repo, prNumber, String(parentId));
+        if (target) {
+            return enqueueReply(payload, deliveryId, "review_comment", String(sourceId), repo, prNumber, asString(comment?.body) ?? "", asString(author?.login), target, asString(comment?.path), asNumber(comment?.line) ?? asNumber(comment?.original_line), asString(comment?.commit_id));
+        }
+    }
+    return reviewWakeEvent("pull_request_review_comment", payload, deliveryId, maxDiffLines);
+}
+function issueCommentEvent(payload, deliveryId) {
+    const action = asString(payload.action) ?? "";
+    const issue = asRecord(payload.issue);
+    const comment = asRecord(payload.comment);
+    const repo = asString(asRecord(payload.repository)?.full_name);
+    const prNumber = asNumber(issue?.number);
+    const sourceId = comment?.id;
+    const author = asRecord(comment?.user);
+    const body = asString(comment?.body) ?? "";
+    if (action !== "created" ||
+        !repo ||
+        prNumber === undefined ||
+        !asRecord(issue?.pull_request) ||
+        (typeof sourceId !== "number" && typeof sourceId !== "string")) {
+        return { outcome: "ignored", repo, prNumber };
+    }
+    if (isBot(author)) {
+        return {
+            outcome: "skipped",
+            reason: "own-comment",
+            repo,
+            prNumber,
+        };
+    }
+    if (!hasAppMention(body, appSlug(payload))) {
+        return {
+            outcome: "ignored",
+            reason: "no-app-mention",
+            repo,
+            prNumber,
+        };
+    }
+    return enqueueReply(payload, deliveryId, "issue_comment", String(sourceId), repo, prNumber, body, asString(author?.login));
+}
+export function dispatchGithubEvent(event, payload, deliveryId, maxDiffLines) {
+    if (event === "installation")
+        return applyInstallation(payload);
+    if (event === "installation_repositories") {
+        return applyInstallationRepositories(payload);
+    }
+    if (event === "pull_request") {
+        return pullRequestEvent(payload, deliveryId, maxDiffLines);
+    }
+    if (event === "pull_request_review_comment") {
+        return reviewCommentEvent(payload, deliveryId, maxDiffLines);
+    }
+    if (event === "pull_request_review") {
+        return reviewWakeEvent(event, payload, deliveryId, maxDiffLines);
+    }
+    if (event === "issue_comment")
+        return issueCommentEvent(payload, deliveryId);
+    return { outcome: "ignored" };
+}

package/dist/src/store/app_db.d.ts

@@ -0,0 +1,10 @@
+import { Database } from "./sqlite.ts";
+export declare function appDbDir(): string;
+/** `CM_APP_DB` overrides the path — tests point it at a temp file. */
+export declare function appDbPath(): string;
+export declare function releaseLock(): Promise<void>;
+/** Opens (creating and migrating if needed) the single shared `app.db`
+ * connection every store module reuses. Call once at `serve` startup. */
+export declare function openAppDb(): Promise<Database>;
+export declare function getAppDb(): Database;
+export declare function closeAppDb(): Promise<void>;

package/dist/src/store/app_db.js

@@ -0,0 +1,85 @@
+import { Database } from "./sqlite.js";
+import { getCacheDir } from "../config.js";
+import { migrations } from "./migrations.js";
+import { getEnv, isNotFound, isProcessAlive, mkdir, readTextFile, remove, writeTextFile, } from "../util/runtime.js";
+export function appDbDir() {
+    return `${getCacheDir()}/co-maintainer`;
+}
+/** `CM_APP_DB` overrides the path — tests point it at a temp file. */
+export function appDbPath() {
+    return getEnv("CM_APP_DB") ?? `${appDbDir()}/app.db`;
+}
+function lockPath() {
+    return `${appDbPath()}.lock`;
+}
+/** A PID file next to the database is the lock: a live PID inside it
+ * refuses a second start, a dead one is taken over silently. */
+async function acquireLock() {
+    const path = lockPath();
+    let existingPid;
+    try {
+        existingPid = Number((await readTextFile(path)).trim());
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            throw error;
+    }
+    if (existingPid !== undefined &&
+        Number.isInteger(existingPid) &&
+        isProcessAlive(existingPid)) {
+        throw new Error(`co-maintainer serve is already running (pid ${existingPid}) against this app.db. Only one serve process may write to it at a time.`);
+    }
+    await writeTextFile(path, String(process.pid));
+}
+export async function releaseLock() {
+    await remove(lockPath()).catch(() => { });
+}
+/** A database already at a migration this binary does not know about means
+ * an older release started against one a newer release already touched —
+ * refuse loudly instead of running unfamiliar structure through old code. */
+function migrate(database) {
+    const current = database.prepare("PRAGMA user_version").get()
+        ?.user_version ?? 0;
+    if (current > migrations.length) {
+        throw new Error(`app.db is at migration ${current}, but this build only knows ${migrations.length}. ` +
+            `Installing an older release after a newer one already migrated the database is unsupported.`);
+    }
+    for (let index = current; index < migrations.length; index++) {
+        database.exec("BEGIN");
+        try {
+            for (const statement of migrations[index])
+                database.exec(statement);
+            database.exec(`PRAGMA user_version = ${index + 1}`);
+            database.exec("COMMIT");
+        }
+        catch (error) {
+            database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+}
+let db;
+/** Opens (creating and migrating if needed) the single shared `app.db`
+ * connection every store module reuses. Call once at `serve` startup. */
+export async function openAppDb() {
+    if (db)
+        return db;
+    await mkdir(appDbDir(), { recursive: true });
+    await acquireLock();
+    const database = new Database(appDbPath());
+    database.exec("PRAGMA journal_mode = WAL");
+    database.exec("PRAGMA foreign_keys = ON");
+    migrate(database);
+    db = database;
+    return database;
+}
+export function getAppDb() {
+    if (!db)
+        throw new Error("app.db is not open; call openAppDb() first");
+    return db;
+}
+export async function closeAppDb() {
+    db?.close();
+    db = undefined;
+    await releaseLock();
+}

package/dist/src/store/cache_db.d.ts

@@ -0,0 +1,4 @@
+export declare function cacheGet(namespace: string, key: string): Promise<string | undefined>;
+export declare function cacheSet(namespace: string, key: string, value: string): Promise<void>;
+export declare function cacheDelete(namespace: string, key: string): Promise<void>;
+export declare function cacheDeletePrefix(namespace: string, prefix: string): Promise<void>;

package/dist/src/store/cache_db.js

@@ -0,0 +1,63 @@
+import { Database } from "./sqlite.js";
+import { cacheDbPath, getCacheDir } from "../config.js";
+import { mkdirSync } from "../util/runtime.js";
+let initialized = false;
+function openDatabase() {
+    mkdirSync(`${getCacheDir()}/co-maintainer`, { recursive: true });
+    const db = new Database(cacheDbPath());
+    if (!initialized) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS cache (
+        namespace TEXT NOT NULL,
+        cache_key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (namespace, cache_key)
+      )
+    `);
+        initialized = true;
+    }
+    return db;
+}
+export async function cacheGet(namespace, key) {
+    const db = openDatabase();
+    try {
+        const row = db
+            .prepare("SELECT value FROM cache WHERE namespace = ? AND cache_key = ?")
+            .get(namespace, key);
+        return row?.value;
+    }
+    finally {
+        db.close();
+    }
+}
+export async function cacheSet(namespace, key, value) {
+    const db = openDatabase();
+    try {
+        db.prepare(`INSERT INTO cache(namespace, cache_key, value, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(namespace, cache_key) DO UPDATE SET
+         value = excluded.value, updated_at = excluded.updated_at`).run(namespace, key, value, new Date().toISOString());
+    }
+    finally {
+        db.close();
+    }
+}
+export async function cacheDelete(namespace, key) {
+    const db = openDatabase();
+    try {
+        db.prepare("DELETE FROM cache WHERE namespace = ? AND cache_key = ?").run(namespace, key);
+    }
+    finally {
+        db.close();
+    }
+}
+export async function cacheDeletePrefix(namespace, prefix) {
+    const db = openDatabase();
+    try {
+        db.prepare("DELETE FROM cache WHERE namespace = ? AND cache_key LIKE ?").run(namespace, `${prefix}%`);
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/src/store/deliveries.d.ts

@@ -0,0 +1,12 @@
+import type { DeliveryRow } from "./rows.ts";
+export declare function recordDelivery(row: {
+    deliveryId: string;
+    event: string;
+    action?: string;
+    repo?: string;
+    prNumber?: number;
+    outcome: string;
+    reason?: string;
+}): void;
+export declare function hasDelivery(deliveryId: string): boolean;
+export declare function listSkipped(repo?: string): DeliveryRow[];

package/dist/src/store/deliveries.js

@@ -0,0 +1,23 @@
+/** Every webhook delivery is recorded here, whether it was acted on or not,
+ * so a skipped pull request stays visible instead of silent. */
+import { getAppDb } from "./app_db.js";
+import { nowIso } from "../util/time.js";
+export function recordDelivery(row) {
+    getAppDb()
+        .prepare(`INSERT INTO deliveries
+       (delivery_id, event, action, repo, pr_number, received_at, outcome, reason)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(row.deliveryId, row.event, row.action ?? null, row.repo ?? null, row.prNumber ?? null, nowIso(), row.outcome, row.reason ?? null);
+}
+export function hasDelivery(deliveryId) {
+    return (getAppDb()
+        .prepare(`SELECT 1 FROM deliveries WHERE delivery_id = ?`)
+        .get(deliveryId) !== undefined);
+}
+export function listSkipped(repo) {
+    const where = repo
+        ? `WHERE outcome != 'enqueued' AND repo = ?`
+        : `WHERE outcome != 'enqueued'`;
+    const db = getAppDb().prepare(`SELECT * FROM deliveries ${where} ORDER BY received_at DESC`);
+    return repo ? db.all(repo) : db.all();
+}

package/dist/src/store/drift.d.ts

@@ -0,0 +1,4 @@
+import type { DriftRow } from "./rows.ts";
+export declare function upsertDrift(row: DriftRow): void;
+export declare function deleteDrift(repo: string): void;
+export declare function getDrift(repo: string): DriftRow | undefined;

package/dist/src/store/drift.js

@@ -0,0 +1,22 @@
+import { getAppDb } from "./app_db.js";
+export function upsertDrift(row) {
+    getAppDb()
+        .prepare(`INSERT INTO drift
+       (repo, as_of, prs_since, prs_updated, commits_since, files_changed)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(repo) DO UPDATE SET
+       as_of = excluded.as_of,
+       prs_since = excluded.prs_since,
+       prs_updated = excluded.prs_updated,
+       commits_since = excluded.commits_since,
+       files_changed = excluded.files_changed`)
+        .run(row.repo, row.as_of, row.prs_since, row.prs_updated, row.commits_since, row.files_changed);
+}
+export function deleteDrift(repo) {
+    getAppDb().prepare(`DELETE FROM drift WHERE repo = ?`).run(repo);
+}
+export function getDrift(repo) {
+    return getAppDb()
+        .prepare(`SELECT * FROM drift WHERE repo = ?`)
+        .get(repo);
+}

package/dist/src/store/findings.d.ts

@@ -0,0 +1,31 @@
+import type { FindingRow } from "./rows.ts";
+export declare function insertFinding(row: {
+    id: string;
+    reviewId: string;
+    severity: string;
+    path?: string;
+    lineFrom?: number;
+    lineTo?: number;
+    title: string;
+    bodyMd: string;
+    firstSeenReviewId?: string;
+    threadCommentId?: string;
+    anchorText?: string | null;
+    state?: string;
+    carriedFromFindingId?: string | null;
+    closeReason?: string | null;
+}): void;
+export declare function listCarryableFindingsForReview(reviewId: string): FindingRow[];
+export declare function setFindingPosted(id: string, postedCommentId: string, threadCommentId?: string): void;
+export declare function listFindingsForReview(reviewId: string): FindingRow[];
+export declare function listFindingsForPr(repo: string, prNumber: number): FindingRow[];
+export declare function findFindingByPostedComment(repo: string, prNumber: number, commentId: string): FindingRow | undefined;
+export type SeverityStats = {
+    severity: string;
+    findings: number;
+    repeats: number;
+    posted: number;
+};
+/** A repeat is a finding the previous round already raised, so the repeat
+ * column reads as "raised again after the author saw it". */
+export declare function findingStatsBySeverity(sinceIso: string): SeverityStats[];