diff-easy 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Sai Mageshvar (diff-easy)
+Copyright (c) 2025 @yoshiko-pg/difit (original difit project this is based on)
+
+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/README.md

@@ -0,0 +1,142 @@
+# diff-easy
+
+A local, browser-based **git diff viewer built for AI-agent workflows**. It runs a
+small web server on your machine (view it in any browser — or Cmux's inline
+browser) and adds two things on top of a plain diff view:
+
+1. **Filter by filename / type, and search within the diff.** Filter the file
+   list by substring, by extension chips (`.ts`, `.tsx`, `.css`, …), and by change
+   status; search diff _content_ across all files with highlight + next/prev.
+2. **Review the diff produced by each AI-agent turn.** A capture hook snapshots
+   your working tree at every Claude Code turn boundary, so you can browse a full
+   timeline of turns and see exactly what each one changed — with **live refresh**
+   as the agent works.
+
+diff-easy is built on a vendored copy of [difit](https://github.com/yoshiko-pg/difit)
+(MIT). See [`NOTICE.md`](./NOTICE.md) for attribution.
+
+## Install
+
+```bash
+# from a clone of this repo
+corepack enable          # provides pnpm
+pnpm install
+pnpm run build
+npm link                 # makes `diff-easy` available on your PATH (optional)
+```
+
+If you don't `npm link`, run it via `node dist/cli/index.js …` (or `pnpm start`).
+
+## Usage
+
+Run inside any git repository:
+
+```bash
+diff-easy                # default: ALL uncommitted changes (staged + unstaged) vs HEAD
+diff-easy working        # unstaged changes only
+diff-easy staged         # staged changes only
+diff-easy HEAD           # the last commit (HEAD^..HEAD)
+diff-easy HEAD~3 HEAD    # a commit range
+diff-easy --port 9100    # pick a port (handy with Cmux per-workspace ports)
+```
+
+It prints a `http://localhost:<port>` URL and opens your browser. In **Cmux**,
+enable "open http/https in the cmux browser" (Settings) and the URL opens right in
+the inline browser pane — or run `cmux browser open <url>`.
+
+### Filter & search
+
+- **File list** (left): type in _Filter files…_, click extension chips to narrow by
+  type, and use the status chips (Added / Modified / …) when more than one status
+  is present.
+- **In-diff search**: press **Cmd/Ctrl+F** (or click the search icon). Enter steps
+  to the next match, Shift+Enter the previous; toggle case sensitivity. Matches are
+  highlighted across every file.
+
+## Use from CMUX
+
+Run this in a repo's CMUX workspace to open/close the hub — scoped to that repo —
+in a browser split pane beside your terminal:
+
+```bash
+diff-easy cmux toggle          # open the split for $PWD if closed, close it if open
+diff-easy cmux open            # just open (re-points the same pane; never closes)
+diff-easy cmux open --no-open  # ensure the hub is up and print the URL
+```
+
+`toggle` starts the always-on hub if needed and opens the diff-easy split scoped
+via a `?repo=` deep-link; running it again closes that split. As the agent edits
+code, the diff (and the agent-turn timeline) update live beside your terminal.
+
+The hub is shared and shows one repo at a time, so toggling in another workspace
+re-points it to that repo. All three accept `--port <n>` (default `4966`; also
+honors `$DIFIT_HUB_PORT`).
+
+All accept `--port <n>` (default `4966`; also honors `$DIFIT_HUB_PORT`).
+
+## Per-turn diffs (Claude Code)
+
+Install the capture hooks once:
+
+```bash
+diff-easy init             # installs into ~/.claude/settings.json (works in every repo)
+diff-easy init --project   # or commit them to ./.claude/settings.json for a single repo
+```
+
+This adds two Claude Code hooks — `UserPromptSubmit` (turn start) and `Stop`
+(turn end). On each boundary, `diff-easy snapshot` records the **entire working
+tree** as a git snapshot (capturing edits from _both_ the Edit/Write tools and
+Bash commands like `sed`/`mv`). Snapshots are anchored under `refs/difit/snapshots`
+so they survive `git gc`, and turn metadata is written to `.difit-turns/log.json`.
+The hook is a no-op outside a git repo and never blocks the agent.
+
+Then, in the viewer, use the **Agent turns** dropdown (top toolbar) to:
+
+- pick **Working dir** for the live diff, or any **Turn N** to see exactly what that
+  turn changed (its diff is `git diff <snapshotBefore> <snapshotAfter>`);
+- stay on **Live** to auto-advance to each new turn as the agent finishes it
+  (powered by an SSE ping from the `Stop` hook).
+
+Capture is decoupled from viewing: turns are recorded whether or not the viewer is
+open, so you can review after the fact.
+
+### Where it writes & data retention
+
+- **`<repo>/.difit-turns/`** — `log.json` (turn metadata) and `server.json`
+  (live-refresh port). Local-only and self-ignored from version control.
+- **`<repo>/.git`** — snapshot commits/trees/blobs, anchored by the single ref
+  `refs/difit/snapshots`. Never touches your branches or normal history. Git
+  deduplicates unchanged file content across snapshots.
+- **OS temp dir (`$TMPDIR`)** — a short-lived git index file per snapshot,
+  deleted immediately (nothing persists there).
+
+**Retention:** each session keeps its **most recent 50 turns**
+(`MAX_TURNS_PER_SESSION`). Older turns are dropped from the log, and their
+snapshot commits stop being referenced by `refs/difit/snapshots`, so a routine
+`git gc` reclaims them — keeping `.git` bounded. To wipe all snapshots manually:
+
+```bash
+git update-ref -d refs/difit/snapshots && git gc --prune=now && rm -rf .difit-turns
+```
+
+## Develop
+
+```bash
+pnpm run build       # build CLI + client
+pnpm run build:cli   # CLI only (type-checks the server/CLI)
+npx tsc --noEmit -p tsconfig.json   # type-check the client
+pnpm test            # run tests
+```
+
+Key diff-easy additions over difit:
+
+- `src/client/components/FileList.tsx` — extension/status filter chips
+- `src/client/hooks/useDiffSearch.ts`, `src/client/components/DiffSearch.tsx` —
+  in-diff search (CSS Custom Highlight API)
+- `src/cli/turns.ts`, `src/utils/turnLog.ts` — `snapshot` / `init` commands + log
+- `src/client/hooks/useTurns.ts`, `src/client/components/TurnTimeline.tsx` — turn UI
+- `src/server/server.ts` — `/api/turns`, `/events/turn-complete`, `server.json`
+
+## License
+
+MIT — see [`LICENSE`](./LICENSE) and [`NOTICE.md`](./NOTICE.md).

package/dist/cli/cmux.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+export declare const DEFAULT_HUB_PORT = 4966;
+export declare function resolveHubPort(flagPort: number | undefined, env: NodeJS.ProcessEnv): number;
+export declare function hubOrigin(port: number): string;
+export declare function buildHubUrl(port: number, repoPath: string): string;
+export declare function shouldReuseSurface(storedRef: string | null, surfaceUrl: string | null, origin: string): boolean;
+export declare function isInsideCmux(env: NodeJS.ProcessEnv): boolean;
+/** Builds the `diff-easy cmux` subcommand (open/toggle). */
+export declare function createCmuxCommand(): Command;

package/dist/cli/cmux.js

@@ -0,0 +1,274 @@
+import { execFileSync, spawn } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { get as httpGet } from 'http';
+import { tmpdir } from 'os';
+import { dirname, join } from 'path';
+import { Command } from 'commander';
+export const DEFAULT_HUB_PORT = 4966;
+export function resolveHubPort(flagPort, env) {
+    if (typeof flagPort === 'number' && Number.isFinite(flagPort))
+        return flagPort;
+    const fromEnv = env.DIFIT_HUB_PORT ? Number.parseInt(env.DIFIT_HUB_PORT, 10) : Number.NaN;
+    return Number.isFinite(fromEnv) ? fromEnv : DEFAULT_HUB_PORT;
+}
+export function hubOrigin(port) {
+    return `http://localhost:${port}`;
+}
+export function buildHubUrl(port, repoPath) {
+    return `${hubOrigin(port)}/?repo=${encodeURIComponent(repoPath)}`;
+}
+export function shouldReuseSurface(storedRef, surfaceUrl, origin) {
+    return Boolean(storedRef) && Boolean(surfaceUrl?.startsWith(origin));
+}
+export function isInsideCmux(env) {
+    return Boolean(env.CMUX_WORKSPACE_ID);
+}
+// ---- surface state (per-workspace pane reuse) ----
+function surfaceStatePath(workspaceId) {
+    return join(tmpdir(), 'diff-easy-cmux', `${workspaceId.replace(/[^\w:-]/g, '_')}.surface`);
+}
+function readStoredSurface(workspaceId) {
+    try {
+        return readFileSync(surfaceStatePath(workspaceId), 'utf8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeStoredSurface(workspaceId, ref) {
+    const p = surfaceStatePath(workspaceId);
+    if (!existsSync(dirname(p)))
+        mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, `${ref}\n`);
+}
+function clearStoredSurface(workspaceId) {
+    try {
+        rmSync(surfaceStatePath(workspaceId), { force: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+// ---- hub liveness ----
+async function isHubUp(port) {
+    return await new Promise((resolve) => {
+        let settled = false;
+        const finish = (up) => {
+            if (settled)
+                return;
+            settled = true;
+            req.destroy();
+            resolve(up);
+        };
+        const req = httpGet(`${hubOrigin(port)}/api/workspaces`, (res) => {
+            res.resume();
+            finish(true);
+        });
+        req.setTimeout(500, () => finish(false));
+        req.on('error', () => finish(false));
+    });
+}
+async function waitForHub(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await isHubUp(port))
+            return true;
+        await new Promise((r) => setTimeout(r, 250));
+    }
+    return false;
+}
+function startHubDetached(port) {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        throw new Error('Unable to determine difit entrypoint for hub background process');
+    }
+    const child = spawn(process.execPath, [scriptPath, 'hub', '--no-open', '--port', String(port)], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+}
+/** Ensure the hub answers on `port`, starting it detached if needed. */
+async function ensureHub(port) {
+    if (await isHubUp(port))
+        return true;
+    console.log(`diff-easy: starting hub on port ${port}…`);
+    startHubDetached(port);
+    if (await waitForHub(port, 5000))
+        return true;
+    console.error(`diff-easy: hub did not come up on port ${port}. Try \`diff-easy hub --port ${port}\`.`);
+    return false;
+}
+// ---- cmux browser surface control ----
+/** Read a CMUX browser surface's current URL, or null if it doesn't resolve. */
+function cmuxSurfaceUrl(ref) {
+    try {
+        return (execFileSync('cmux', ['browser', '--surface', ref, 'url'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })
+            .toString()
+            .trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+/** Open a new browser split and return the created surface ref (best-effort). */
+function cmuxOpenSplit(url) {
+    try {
+        const out = execFileSync('cmux', ['browser', 'open-split', url, '--focus', 'true'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).toString();
+        const match = out.match(/surface:\d+/);
+        return match ? match[0] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Re-point an existing browser surface at `url` and bring it forward. Returns
+ * false if the surface can't be navigated (e.g. it was closed), so the caller
+ * can fall back to opening a fresh split. Note: `cmux browser navigate` does
+ * NOT accept `--focus`; focusing is a separate best-effort call.
+ */
+function cmuxNavigate(ref, url) {
+    try {
+        execFileSync('cmux', ['browser', '--surface', ref, 'navigate', url], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return false;
+    }
+    try {
+        execFileSync('cmux', ['browser', '--surface', ref, 'focus-webview'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        // focus is best-effort — the navigate already succeeded
+    }
+    return true;
+}
+/** Close a CMUX browser surface (best-effort). */
+function cmuxCloseSurface(ref) {
+    try {
+        execFileSync('cmux', ['browser', '--surface', ref, 'tab', 'close'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        // best-effort
+    }
+}
+function isGitWorkTree(cwd) {
+    try {
+        return (execFileSync('git', ['-C', cwd, 'rev-parse', '--is-inside-work-tree'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })
+            .toString()
+            .trim() === 'true');
+    }
+    catch {
+        return false;
+    }
+}
+// ---- open / close / toggle ----
+/** Open (or re-point) the diff-easy browser split for `cwd` in this workspace. */
+function openPane(port, cwd, workspaceId) {
+    const url = buildHubUrl(port, cwd);
+    const stored = readStoredSurface(workspaceId);
+    if (shouldReuseSurface(stored, stored ? cmuxSurfaceUrl(stored) : null, hubOrigin(port)) &&
+        cmuxNavigate(stored, url)) {
+        console.log(`diff-easy: re-pointed diff-easy pane to ${cwd}`);
+        return;
+    }
+    const ref = cmuxOpenSplit(url);
+    if (ref)
+        writeStoredSurface(workspaceId, ref);
+    console.log(`diff-easy: opened diff-easy split pane for ${cwd}`);
+}
+/**
+ * Close the diff-easy pane if it's currently open on our hub. Returns true when
+ * a pane was closed. Clears a stale stored ref either way.
+ */
+function closePane(workspaceId, port) {
+    const stored = readStoredSurface(workspaceId);
+    const open = shouldReuseSurface(stored, stored ? cmuxSurfaceUrl(stored) : null, hubOrigin(port));
+    if (open) {
+        cmuxCloseSurface(stored);
+        clearStoredSurface(workspaceId);
+        return true;
+    }
+    if (stored)
+        clearStoredSurface(workspaceId);
+    return false;
+}
+function warnIfNotGit(cwd) {
+    if (!isGitWorkTree(cwd)) {
+        console.warn(`diff-easy: ${cwd} is not a git repository — the hub can't scope to it.`);
+    }
+}
+function notInsideCmuxMessage(port, cwd) {
+    console.log(`diff-easy: not inside CMUX. Open this URL to review ${cwd}:\n  ${buildHubUrl(port, cwd)}`);
+}
+async function runCmuxOpen(options) {
+    const port = resolveHubPort(options.port, process.env);
+    const cwd = process.cwd();
+    warnIfNotGit(cwd);
+    if (!(await ensureHub(port)))
+        process.exit(1);
+    if (options.open === false) {
+        console.log(buildHubUrl(port, cwd));
+        return;
+    }
+    const workspaceId = process.env.CMUX_WORKSPACE_ID;
+    if (!isInsideCmux(process.env) || !workspaceId) {
+        notInsideCmuxMessage(port, cwd);
+        return;
+    }
+    openPane(port, cwd, workspaceId);
+}
+async function runCmuxToggle(options) {
+    const port = resolveHubPort(options.port, process.env);
+    const cwd = process.cwd();
+    const workspaceId = process.env.CMUX_WORKSPACE_ID;
+    if (!isInsideCmux(process.env) || !workspaceId) {
+        warnIfNotGit(cwd);
+        if (!(await ensureHub(port)))
+            process.exit(1);
+        notInsideCmuxMessage(port, cwd);
+        return;
+    }
+    // Open → close; closed → open.
+    if (closePane(workspaceId, port)) {
+        console.log('diff-easy: closed diff-easy pane');
+        return;
+    }
+    warnIfNotGit(cwd);
+    if (!(await ensureHub(port)))
+        process.exit(1);
+    openPane(port, cwd, workspaceId);
+}
+/** Builds the `diff-easy cmux` subcommand (open/toggle). */
+export function createCmuxCommand() {
+    const cmux = new Command('cmux').description('CMUX integration: open/toggle diff-easy for the current repo in a browser split pane');
+    const portOption = (value) => Number.parseInt(value, 10);
+    cmux
+        .command('open', { isDefault: true })
+        .description('Ensure the hub is running and open it (scoped to $PWD) in a CMUX browser split pane')
+        .option('--port <port>', 'hub port (default 4966; also honors $DIFIT_HUB_PORT)', portOption)
+        .option('--no-open', 'ensure the hub is up and print the URL, without opening a pane')
+        .action(async (options) => {
+        await runCmuxOpen(options);
+    });
+    cmux
+        .command('toggle')
+        .description('Toggle the diff-easy browser split for $PWD (open if closed, close if open)')
+        .option('--port <port>', 'hub port (default 4966; also honors $DIFIT_HUB_PORT)', portOption)
+        .action(async (options) => {
+        await runCmuxToggle(options);
+    });
+    return cmux;
+}

package/dist/cli/comment.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createCommentCommand(): Command;

package/dist/cli/comment.js

@@ -0,0 +1,91 @@
+import { Command, Option } from 'commander';
+import { parseCommentImportValue } from '../utils/commentImports.js';
+import { detectStdinSource, readStdin } from './utils.js';
+async function parseCommentAddInput(json) {
+    if (typeof json === 'string') {
+        return json;
+    }
+    if (detectStdinSource() === 'tty') {
+        throw new Error('Provide comment JSON as an argument or via stdin');
+    }
+    const stdin = await readStdin();
+    if (!stdin.trim()) {
+        throw new Error('No comment JSON received from stdin');
+    }
+    return stdin;
+}
+export function createCommentCommand() {
+    const comment = new Command('comment').description('Add or retrieve comments on a running difit server');
+    comment
+        .command('add')
+        .description('Add comments to a running difit server')
+        .argument('[json]', 'comment import JSON (object or array)')
+        .requiredOption('--port <port>', 'port of the running difit server', parseInt)
+        .action(async (json, opts) => {
+        try {
+            const input = await parseCommentAddInput(json);
+            const imports = parseCommentImportValue(input);
+            const response = await fetch(`http://localhost:${opts.port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(imports),
+            });
+            if (!response.ok) {
+                const errorBody = (await response.json().catch(() => ({})));
+                console.error(`Error: ${errorBody.error ?? 'Failed to add comments'}`);
+                process.exit(1);
+            }
+            const result = (await response.json());
+            console.log(JSON.stringify({
+                success: result.success ?? true,
+                importId: result.importId,
+                count: result.count ?? imports.length,
+                warnings: result.warnings ?? [],
+            }));
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message.includes('fetch failed')) {
+                console.error(`Error: Cannot connect to difit server on port ${opts.port}. Is the server running?`);
+            }
+            else {
+                console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+            process.exit(1);
+        }
+    });
+    comment
+        .command('get')
+        .description('Retrieve comments from a running difit server')
+        .requiredOption('--port <port>', 'port of the running difit server', parseInt)
+        .addOption(new Option('--format <format>', 'output format').choices(['text', 'json']).default('text'))
+        .action(async (opts) => {
+        try {
+            const endpoint = opts.format === 'json' ? '/api/comments-json' : '/api/comments-output';
+            const response = await fetch(`http://localhost:${opts.port}${endpoint}`);
+            if (!response.ok) {
+                console.error('Error: Failed to retrieve comments');
+                process.exit(1);
+            }
+            if (opts.format === 'json') {
+                const data = await response.json();
+                console.log(JSON.stringify(data));
+            }
+            else {
+                const text = await response.text();
+                if (text.trim()) {
+                    console.log(text);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message.includes('fetch failed')) {
+                console.error(`Error: Cannot connect to difit server on port ${opts.port}. Is the server running?`);
+            }
+            else {
+                console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+            process.exit(1);
+        }
+    });
+    return comment;
+}

package/dist/cli/github.d.ts

@@ -0,0 +1,84 @@
+import type { CommentImport } from '../types/diff.js';
+interface PullRequestInfo {
+    owner: string;
+    repo: string;
+    pullNumber: number;
+    hostname: string;
+}
+interface GitHubReviewThreadAuthor {
+    login?: string | null;
+}
+interface GitHubReviewThreadCommentNode {
+    id?: string | null;
+    body?: string | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    author?: GitHubReviewThreadAuthor | null;
+}
+interface GitHubReviewThreadNode {
+    id?: string | null;
+    isResolved?: boolean | null;
+    isOutdated?: boolean | null;
+    subjectType?: string | null;
+    path?: string | null;
+    diffSide?: string | null;
+    startDiffSide?: string | null;
+    line?: number | null;
+    startLine?: number | null;
+    originalLine?: number | null;
+    originalStartLine?: number | null;
+    comments?: {
+        nodes?: GitHubReviewThreadCommentNode[] | null;
+    } | null;
+}
+interface GitHubReviewThreadsPageInfo {
+    hasNextPage?: boolean | null;
+    endCursor?: string | null;
+}
+interface GitHubReviewThreadsConnection {
+    nodes?: GitHubReviewThreadNode[] | null;
+    pageInfo?: GitHubReviewThreadsPageInfo | null;
+}
+interface GitHubReviewThreadsGraphqlResponse {
+    data?: {
+        repository?: {
+            pullRequest?: {
+                reviewThreads?: GitHubReviewThreadsConnection | null;
+            } | null;
+        } | null;
+    } | null;
+    errors?: Array<{
+        message?: string | null;
+    }> | null;
+}
+interface PrCommentImportsPage {
+    commentImports: CommentImport[];
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor: string | null;
+    };
+}
+export interface PullRequestDetails {
+    title: string;
+    body: string;
+}
+interface GitHubPrDetailsGraphqlResponse {
+    data?: {
+        repository?: {
+            pullRequest?: {
+                title?: string | null;
+                body?: string | null;
+            } | null;
+        } | null;
+    } | null;
+    errors?: Array<{
+        message?: string | null;
+    }> | null;
+}
+export declare function parseGitHubPrUrl(url: string): PullRequestInfo | null;
+export declare function getPrPatch(prArg: string): string;
+export declare function parsePrCommentImportsResponse(response: GitHubReviewThreadsGraphqlResponse): PrCommentImportsPage;
+export declare function getPrCommentImports(prArg: string): Promise<CommentImport[]>;
+export declare function parsePrDetailsResponse(response: GitHubPrDetailsGraphqlResponse): PullRequestDetails | null;
+export declare function getPrDetails(prArg: string): Promise<PullRequestDetails | null>;
+export {};