co-maintainer 0.4.0-beta.1

package/dist/src/pr/checkout.js

@@ -0,0 +1,136 @@
+import { cloneDir, worktreeDir } from "../config.js";
+import { log } from "../util/log.js";
+import { withKeyedLock } from "../util/keyed_lock.js";
+import { commandOutput, isWindows, stat } from "../util/runtime.js";
+export function withCloneLock(repo, fn) {
+    return withKeyedLock(`clone:${repo}`, fn);
+}
+export async function runCommand(command, args, cwd) {
+    // Windows resolves git and other shims through the shell, not as bare exes.
+    const windows = isWindows();
+    const output = await commandOutput(windows ? "cmd" : command, {
+        args: windows ? ["/c", command, ...args] : args,
+        cwd,
+        stdout: "piped",
+        stderr: "piped",
+    });
+    return {
+        code: output.code,
+        stdout: new TextDecoder().decode(output.stdout),
+        stderr: new TextDecoder().decode(output.stderr),
+    };
+}
+export async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function cloneInto(repo, dir, run) {
+    log("checkout", `cloning ${repo} into ${dir}`);
+    const started = performance.now();
+    const result = await run("git", [
+        "clone",
+        "--filter=blob:none",
+        `https://github.com/${repo}`,
+        dir,
+    ]);
+    if (result.code !== 0) {
+        throw new Error(`git clone failed: ${result.stderr.trim()}`);
+    }
+    // Deep source trees overrun the Windows path limit even under a short root.
+    await run("git", ["config", "core.longpaths", "true"], dir);
+    log("checkout", `cloned in ${((performance.now() - started) / 1000).toFixed(1)}s`);
+    return dir;
+}
+/** In-flight clone per destination directory. A benchmark run reviews several
+ * PRs of the same repo concurrently, and each one's scope/map computation
+ * calls `ensureClone` independently; without this, the first concurrent burst
+ * has every caller see "not cloned yet" and race `git clone` into the same
+ * directory — one wins, the rest fail with "already exists" and silently fall
+ * back to an unscoped review. Concurrent callers now await the one real clone
+ * instead. The two statements between the `pathExists` check and this map's
+ * `get`/`set` are synchronous (no `await` between them), so whichever caller's
+ * continuation runs first registers the clone before any other caller can
+ * observe an empty map entry — ordinary JS single-threaded scheduling, not a
+ * lock. */
+const cloningInFlight = new Map();
+/** Like `ensureClone` but assumes the caller already holds `withCloneLock`. */
+export async function ensureCloneUnlocked(repo, run) {
+    const dir = cloneDir(repo);
+    if (await pathExists(`${dir}/.git`))
+        return dir;
+    let promise = cloningInFlight.get(dir);
+    if (!promise) {
+        promise = cloneInto(repo, dir, run).finally(() => {
+            cloningInFlight.delete(dir);
+        });
+        cloningInFlight.set(dir, promise);
+    }
+    return promise;
+}
+export async function ensureClone(repo, run) {
+    return withCloneLock(repo, () => ensureCloneUnlocked(repo, run));
+}
+/** Resolves `candidate` to a commit SHA, or returns undefined. Two plain
+ * commands rather than one `rev-parse <rev>^{commit}`: on Windows this runs
+ * through `cmd /c`, where `^` is the shell's own escape character and would
+ * silently eat the peel suffix, making a present commit look absent — the
+ * same trap `benchmark/core_v2/runners.ts`'s `requireCommit` avoids for the same
+ * reason. `cat-file -t` after a caret-free `rev-parse` sidesteps it. */
+async function resolveCommit(clone, candidate, run) {
+    const rev = await run("git", ["rev-parse", "--verify", "-q", candidate], clone);
+    if (rev.code !== 0)
+        return undefined;
+    const sha = rev.stdout.trim();
+    const type = await run("git", ["cat-file", "-t", sha], clone);
+    if (type.code !== 0 || type.stdout.trim() !== "commit")
+        return undefined;
+    return sha;
+}
+/** Resolves `revision` — a branch name, a remote-tracking ref, or a commit SHA
+ * — to a commit SHA, fetching it directly if it is a SHA the clone does not
+ * have. A round's boundary commit is often reachable only by SHA once its
+ * branch has moved on or the PR was squash-merged, so no local or
+ * remote-tracking ref points at it any more. */
+export async function ensureCommit(clone, revision, run) {
+    for (const candidate of [revision, `origin/${revision}`]) {
+        const sha = await resolveCommit(clone, candidate, run);
+        if (sha)
+            return sha;
+    }
+    log("checkout", `fetching ${revision.slice(0, 10)}`);
+    const fetched = await run("git", ["fetch", "origin", revision], clone);
+    if (fetched.code !== 0) {
+        throw new Error(`git fetch ${revision} failed: ${fetched.stderr.trim()}`);
+    }
+    const sha = await resolveCommit(clone, revision, run);
+    if (!sha) {
+        throw new Error(`fetched ${revision} but it still does not resolve to a commit`);
+    }
+    return sha;
+}
+export async function ensureWorktree(repo, pr, commit, run) {
+    return withCloneLock(repo, async () => {
+        const clone = await ensureCloneUnlocked(repo, run);
+        const sha = await ensureCommit(clone, commit, run);
+        const dir = worktreeDir(repo, pr);
+        if (await pathExists(`${dir}/.git`)) {
+            log("checkout", `reusing worktree ${dir}`);
+            const reset = await run("git", ["checkout", "-q", "--detach", sha], dir);
+            if (reset.code !== 0) {
+                throw new Error(`checkout ${sha} failed: ${reset.stderr.trim()}`);
+            }
+            return dir;
+        }
+        log("checkout", `creating worktree ${dir} at ${sha.slice(0, 10)}`);
+        const added = await run("git", ["worktree", "add", "-q", "--detach", dir, sha], clone);
+        if (added.code !== 0) {
+            throw new Error(`git worktree add failed: ${added.stderr.trim()}`);
+        }
+        return dir;
+    });
+}

package/dist/src/pr/codegraph_tool_args.d.ts

@@ -0,0 +1,8 @@
+type Args = Record<string, unknown>;
+export declare function toolError(message: string): string;
+export declare function rejectUnknownKeys(args: Args, allowed: ReadonlySet<string>): string | null;
+export declare function rejectFlagLike(value: string, label: string): string | null;
+/** Repo-relative path only — no `..`, no absolute paths (plan E103). */
+export declare function rejectEscapingPath(file: string): string | null;
+export declare function guardToolArgs(args: Args, allowed: ReadonlySet<string>): string | null;
+export {};

package/dist/src/pr/codegraph_tool_args.js

@@ -0,0 +1,34 @@
+export function toolError(message) {
+    return `Tool error: ${message}`;
+}
+export function rejectUnknownKeys(args, allowed) {
+    for (const key of Object.keys(args)) {
+        if (!allowed.has(key))
+            return toolError(`unknown key: ${key}`);
+    }
+    return null;
+}
+export function rejectFlagLike(value, label) {
+    if (value.startsWith("-")) {
+        return toolError(`${label} must not start with '-'`);
+    }
+    return null;
+}
+/** Repo-relative path only — no `..`, no absolute paths (plan E103). */
+export function rejectEscapingPath(file) {
+    const flag = rejectFlagLike(file, "file");
+    if (flag)
+        return flag;
+    const norm = file.replace(/\\/g, "/");
+    if (norm.startsWith("/") ||
+        norm.startsWith("//") ||
+        /^[A-Za-z]:\//.test(norm) ||
+        /^[A-Za-z]:$/.test(norm) ||
+        norm.split("/").includes("..")) {
+        return toolError("file must stay inside the repository");
+    }
+    return null;
+}
+export function guardToolArgs(args, allowed) {
+    return rejectUnknownKeys(args, allowed);
+}

package/dist/src/pr/codegraph_tools.d.ts

@@ -0,0 +1,15 @@
+import type { ToolHandler } from "../ai/mermaid_loop.ts";
+import { type Run } from "./checkout.ts";
+import { type Presence } from "../tools/codegraph.ts";
+import { type CodegraphRunner } from "../tools/codegraph_exec.ts";
+export declare function ensureCodegraphIndex(binary: string, worktree: string, runner: CodegraphRunner, indexDir?: string): Promise<void>;
+/** Uses `detect`, never `ensureCodegraph`: the latter can call `Deno.exit` on
+ * a declined or failed install, fine for a one-time `init`/`remake`/`serve`
+ * setup step but not for a single review that happens to want this tool. */
+export declare function prepareCodegraphTools(repo: string, pr: number, commit: string, options?: {
+    run?: Run;
+    detect?: () => Promise<Presence>;
+}): Promise<ToolHandler[]>;
+/** Tool schemas for the remote bridge (runs are proxied to the CLI). */
+export declare function codegraphToolHandlersForBridge(): ToolHandler[];
+export declare function codegraphTools(binary: string, worktree: string, runner?: CodegraphRunner): ToolHandler[];

package/dist/src/pr/codegraph_tools.js

@@ -0,0 +1,408 @@
+import { ensureWorktree, pathExists, runCommand, } from "./checkout.js";
+import { detect } from "../tools/codegraph.js";
+import { createCodegraphRunner, LOCAL_CODEGRAPH_DIR, runCodegraphTool, SERVER_CODEGRAPH_DIR, } from "../tools/codegraph_exec.js";
+import { log } from "../util/log.js";
+import { guardToolArgs, rejectEscapingPath, rejectFlagLike, } from "./codegraph_tool_args.js";
+function str(args, key) {
+    const value = args[key];
+    return typeof value === "string" && value.trim() !== ""
+        ? value.trim()
+        : undefined;
+}
+function num(args, key) {
+    const value = args[key];
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function strArray(args, key) {
+    const value = args[key];
+    return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+export async function ensureCodegraphIndex(binary, worktree, runner, indexDir = SERVER_CODEGRAPH_DIR) {
+    const started = performance.now();
+    const fresh = !(await pathExists(`${worktree}/${indexDir}`));
+    const initCmd = indexDir === LOCAL_CODEGRAPH_DIR ? ["init", "-y", "."] : ["init", "."];
+    let result = await runner(binary, fresh ? initCmd : ["sync", "."], worktree);
+    if (!fresh &&
+        result.code !== 0 &&
+        /lock/i.test(result.stderr + result.stdout)) {
+        await runner(binary, ["unlock", "."], worktree);
+        result = await runner(binary, ["sync", "."], worktree);
+    }
+    if (result.code !== 0) {
+        result = await runner(binary, ["index", "."], worktree);
+    }
+    if (result.code !== 0) {
+        throw new Error(`codegraph ${fresh ? "init" : "sync"} failed: ${result.stderr.trim() || result.stdout.trim()}`);
+    }
+    const indexed = result.stdout.match(/Indexed ([\d.]+) files/)?.[1] ??
+        result.stdout.match(/Synced (\d+) changed files/)?.[1] ??
+        "?";
+    log("codegraph", `${fresh ? "init" : "sync"} · ${indexed} files · ${((performance.now() - started) /
+        1000).toFixed(1)}s`);
+}
+/** Uses `detect`, never `ensureCodegraph`: the latter can call `Deno.exit` on
+ * a declined or failed install, fine for a one-time `init`/`remake`/`serve`
+ * setup step but not for a single review that happens to want this tool. */
+export async function prepareCodegraphTools(repo, pr, commit, options = {}) {
+    const runner = options.run ?? runCommand;
+    const detectPresence = options.detect ?? detect;
+    try {
+        const presence = await detectPresence();
+        if (presence.state !== "ok") {
+            log("codegraph", `tools unavailable · codegraph is ${presence.state}`);
+            return [];
+        }
+        const worktree = await ensureWorktree(repo, pr, commit, runner);
+        const cgRun = createCodegraphRunner(SERVER_CODEGRAPH_DIR);
+        await ensureCodegraphIndex(presence.path, worktree, cgRun);
+        return codegraphTools(presence.path, worktree, cgRun);
+    }
+    catch (error) {
+        log("codegraph", `tools unavailable · ${String(error)}`);
+        return [];
+    }
+}
+/** Tool schemas for the remote bridge (runs are proxied to the CLI). */
+export function codegraphToolHandlersForBridge() {
+    return codegraphTools("codegraph", ".", createCodegraphRunner(SERVER_CODEGRAPH_DIR));
+}
+export function codegraphTools(binary, worktree, runner = createCodegraphRunner(SERVER_CODEGRAPH_DIR)) {
+    const run = (args) => runCodegraphTool(binary, args, worktree, runner);
+    return [
+        {
+            name: "codegraph-query",
+            tool: {
+                type: "function",
+                function: {
+                    name: "codegraph-query",
+                    description: "Search for symbols (functions, classes, types, etc.) by name across the indexed repository.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            search: {
+                                type: "string",
+                                description: "The symbol name or search term.",
+                            },
+                            kind: {
+                                type: "string",
+                                description: "Restrict to a node kind, e.g. function, class.",
+                            },
+                            limit: {
+                                type: "number",
+                                description: "Maximum results (default 10).",
+                            },
+                        },
+                        required: ["search"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            run: (args) => {
+                const a = args;
+                const keys = new Set(["search", "kind", "limit"]);
+                const guard = guardToolArgs(a, keys);
+                if (guard)
+                    return Promise.resolve(guard);
+                const search = str(a, "search");
+                if (!search) {
+                    return Promise.resolve("codegraph-query requires 'search'.");
+                }
+                const flag = rejectFlagLike(search, "search");
+                if (flag)
+                    return Promise.resolve(flag);
+                const kind = str(a, "kind");
+                if (kind) {
+                    const kindFlag = rejectFlagLike(kind, "kind");
+                    if (kindFlag)
+                        return Promise.resolve(kindFlag);
+                }
+                const limit = num(a, "limit");
+                return run([
+                    "query",
+                    search,
+                    ...(kind ? ["-k", kind] : []),
+                    ...(limit ? ["-l", String(limit)] : []),
+                ]);
+            },
+        },
+        {
+            name: "codegraph-node",
+            tool: {
+                type: "function",
+                function: {
+                    name: "codegraph-node",
+                    description: "One symbol's source plus its caller/callee trail, given its name. Or, with `file` set instead, that file's own symbol map and dependents.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            name: {
+                                type: "string",
+                                description: "A symbol name to look up.",
+                            },
+                            file: {
+                                type: "string",
+                                description: "A file path — reads the file's symbol map instead of a single symbol.",
+                            },
+                            symbolsOnly: {
+                                type: "boolean",
+                                description: "With `file`: return only the symbol map, not source text.",
+                            },
+                        },
+                        additionalProperties: false,
+                    },
+                },
+            },
+            run: (args) => {
+                const a = args;
+                const keys = new Set(["name", "file", "symbolsOnly"]);
+                const guard = guardToolArgs(a, keys);
+                if (guard)
+                    return Promise.resolve(guard);
+                const name = str(a, "name");
+                const file = str(a, "file");
+                if (!name && !file) {
+                    return Promise.resolve("codegraph-node requires 'name' or 'file'.");
+                }
+                if (name) {
+                    const flag = rejectFlagLike(name, "name");
+                    if (flag)
+                        return Promise.resolve(flag);
+                }
+                if (file) {
+                    const pathErr = rejectEscapingPath(file);
+                    if (pathErr)
+                        return Promise.resolve(pathErr);
+                }
+                return run([
+                    "node",
+                    ...(name ? [name] : []),
+                    ...(file ? ["-f", file] : []),
+                    ...(a.symbolsOnly ? ["--symbols-only"] : []),
+                ]);
+            },
+        },
+        {
+            name: "codegraph-explore",
+            tool: {
+                type: "function",
+                function: {
+                    name: "codegraph-explore",
+                    description: "Explore an area of the codebase by a natural-language query: relevant symbols' source and call paths in one shot.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            query: {
+                                type: "string",
+                                description: "What to explore, in plain words.",
+                            },
+                            maxFiles: {
+                                type: "number",
+                                description: "Maximum number of files to include source from.",
+                            },
+                        },
+                        required: ["query"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            run: (args) => {
+                const a = args;
+                const keys = new Set(["query", "maxFiles"]);
+                const guard = guardToolArgs(a, keys);
+                if (guard)
+                    return Promise.resolve(guard);
+                const query = str(a, "query");
+                if (!query) {
+                    return Promise.resolve("codegraph-explore requires 'query'.");
+                }
+                const flag = rejectFlagLike(query, "query");
+                if (flag)
+                    return Promise.resolve(flag);
+                const parts = query.split(/\s+/).filter(Boolean);
+                for (const part of parts) {
+                    const partFlag = rejectFlagLike(part, "query");
+                    if (partFlag)
+                        return Promise.resolve(partFlag);
+                }
+                const maxFiles = num(a, "maxFiles");
+                return run([
+                    "explore",
+                    ...parts,
+                    ...(maxFiles ? ["--max-files", String(maxFiles)] : []),
+                ]);
+            },
+        },
+        {
+            name: "codegraph-callers",
+            tool: {
+                type: "function",
+                function: {
+                    name: "codegraph-callers",
+                    description: "Find every function or method that calls a specific symbol.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            symbol: { type: "string" },
+                            limit: {
+                                type: "number",
+                                description: "Maximum results (default 20).",
+                            },
+                        },
+                        required: ["symbol"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            run: (args) => {
+                const a = args;
+                const keys = new Set(["symbol", "limit"]);
+                const guard = guardToolArgs(a, keys);
+                if (guard)
+                    return Promise.resolve(guard);
+                const symbol = str(a, "symbol");
+                if (!symbol) {
+                    return Promise.resolve("codegraph-callers requires 'symbol'.");
+                }
+                const flag = rejectFlagLike(symbol, "symbol");
+                if (flag)
+                    return Promise.resolve(flag);
+                const limit = num(a, "limit");
+                return run([
+                    "callers",
+                    symbol,
+                    ...(limit ? ["-l", String(limit)] : []),
+                ]);
+            },
+        },
+        {
+            name: "codegraph-callees",
+            tool: {
+                type: "function",
+                function: {
+                    name: "codegraph-callees",
+                    description: "Find every function or method that a specific symbol calls.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            symbol: { type: "string" },
+                            limit: {
+                                type: "number",
+                                description: "Maximum results (default 20).",
+                            },
+                        },
+                        required: ["symbol"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            run: (args) => {
+                const a = args;
+                const keys = new Set(["symbol", "limit"]);
+                const guard = guardToolArgs(a, keys);
+                if (guard)
+                    return Promise.resolve(guard);
+                const symbol = str(a, "symbol");
+                if (!symbol) {
+                    return Promise.resolve("codegraph-callees requires 'symbol'.");
+                }
+                const flag = rejectFlagLike(symbol, "symbol");
+                if (flag)
+                    return Promise.resolve(flag);
+                const limit = num(a, "limit");
+                return run([
+                    "callees",
+                    symbol,
+                    ...(limit ? ["-l", String(limit)] : []),
+                ]);
+            },
+        },
+        {
+            name: "codegraph-impact",
+            tool: {
+                type: "function",
+                function: {
+                    name: "codegraph-impact",
+                    description: "Analyze what else in the codebase is affected by changing a specific symbol — its blast radius.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            symbol: { type: "string" },
+                            depth: {
+                                type: "number",
+                                description: "Traversal depth (default 2).",
+                            },
+                        },
+                        required: ["symbol"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            run: (args) => {
+                const a = args;
+                const keys = new Set(["symbol", "depth"]);
+                const guard = guardToolArgs(a, keys);
+                if (guard)
+                    return Promise.resolve(guard);
+                const symbol = str(a, "symbol");
+                if (!symbol) {
+                    return Promise.resolve("codegraph-impact requires 'symbol'.");
+                }
+                const flag = rejectFlagLike(symbol, "symbol");
+                if (flag)
+                    return Promise.resolve(flag);
+                const depth = num(a, "depth");
+                return run(["impact", symbol, ...(depth ? ["-d", String(depth)] : [])]);
+            },
+        },
+        {
+            name: "codegraph-affected",
+            tool: {
+                type: "function",
+                function: {
+                    name: "codegraph-affected",
+                    description: "Find test files affected by one or more changed source files — the direct way to check whether a change is covered by any test, instead of guessing from the diff.",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            files: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Changed file paths, exactly as shown in this pull request.",
+                            },
+                            depth: {
+                                type: "number",
+                                description: "Max dependency traversal depth (default 5).",
+                            },
+                        },
+                        required: ["files"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            run: (args) => {
+                const a = args;
+                const keys = new Set(["files", "depth"]);
+                const guard = guardToolArgs(a, keys);
+                if (guard)
+                    return Promise.resolve(guard);
+                const files = strArray(a, "files");
+                if (files.length === 0) {
+                    return Promise.resolve("codegraph-affected requires a non-empty 'files' array.");
+                }
+                for (const file of files) {
+                    const pathErr = rejectEscapingPath(file);
+                    if (pathErr)
+                        return Promise.resolve(pathErr);
+                }
+                const depth = num(a, "depth");
+                return run([
+                    "affected",
+                    ...files,
+                    ...(depth ? ["-d", String(depth)] : []),
+                ]);
+            },
+        },
+    ];
+}

package/dist/src/pr/diff_summary.d.ts

@@ -0,0 +1,6 @@
+import type { AiProvider, AiResponse, Json } from "../types.ts";
+export declare const DIFF_SUMMARY_THRESHOLD = 500;
+export declare function needsSummary(changes: number, patch: string): boolean;
+export declare function summarizeDiff(path: string, patch: string, provider: AiProvider, usage?: (response: AiResponse) => Promise<void>): Promise<string>;
+export declare const READ_FULL_DIFF_TOOL: Json;
+export declare function readFullDiff(patchByPath: Map<string, string>, args: unknown): string;

package/dist/src/pr/diff_summary.js

@@ -0,0 +1,52 @@
+import { numberPatch } from "./hunks.js";
+export const DIFF_SUMMARY_THRESHOLD = 500;
+export function needsSummary(changes, patch) {
+    return patch !== "" && changes > DIFF_SUMMARY_THRESHOLD;
+}
+// No system prompt, low max output: a mechanical description, not reasoning.
+export async function summarizeDiff(path, patch, provider, usage) {
+    const response = await provider.complete({
+        job: "summarize_large_diff",
+        prompt: `Summarize this diff for \`${path}\` in 3-5 sentences: what changed, the
+mechanism, and precisely which branches, patterns, or call paths are affected.
+Do not speculate beyond what the diff shows. Do not suggest fixes or judge
+whether the change is correct — only describe it.
+
+${patch}`,
+        maxTokens: 500,
+    });
+    if (usage)
+        await usage(response);
+    return response.text.trim();
+}
+export const READ_FULL_DIFF_TOOL = {
+    type: "function",
+    function: {
+        name: "read-full-diff",
+        description: "Read the complete, untruncated diff for one file in this pull request's own changes. Only files whose diff was summarized (over 500 changed lines) are available this way — everything else is already shown in full.",
+        parameters: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "The file path exactly as it appears in this prompt's DIFF or PULL REQUEST section.",
+                },
+            },
+            required: ["path"],
+            additionalProperties: false,
+        },
+    },
+};
+// The patch is already in memory from the compare API, so this is a plain
+// lookup, not a network or git call.
+export function readFullDiff(patchByPath, args) {
+    const path = String(args?.path ?? "");
+    const patch = patchByPath.get(path);
+    if (patch)
+        return numberPatch(patch);
+    return patchByPath.size === 0
+        ? "No large files were summarized in this review; every file's diff is already shown in full above."
+        : `No summarized diff found for \`${path}\`. Summarized files: ${[
+            ...patchByPath.keys(),
+        ].join(", ")}`;
+}

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

@@ -0,0 +1,14 @@
+export type Span = {
+    path: string;
+    from: number;
+    to: number;
+};
+export type ParsedFinding = Span & {
+    heading: string;
+    excerpt: string;
+    severity?: string;
+    blocking?: boolean;
+    symbol?: string;
+    summary?: string;
+};
+export declare function parseFindings(markdown: string): ParsedFinding[];