chatroom-cli 1.31.1 → 1.32.1

package/dist/infrastructure/git/git-reader.js

@@ -0,0 +1,711 @@
+/**
+ * Git command execution wrappers.
+ *
+ * All functions return discriminated unions — no throws.
+ * Errors from git (non-zero exit) or missing git installation are
+ * captured and returned as `{ status: 'error' }` or `{ status: 'not_found' }`.
+ */
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { FULL_DIFF_MAX_BYTES } from './types.js';
+const execAsync = promisify(exec);
+// ─── Internal Helpers ────────────────────────────────────────────────────────
+/**
+ * Run a git command in `cwd`.
+ * Returns `{ stdout, stderr }` on success, `{ error }` on failure.
+ * Never throws.
+ */
+async function runGit(args, cwd) {
+    try {
+        const result = await execAsync(`git ${args}`, {
+            cwd,
+            // Disable paging and colour for scriptable output
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_PAGER: 'cat', NO_COLOR: '1' },
+            // Increase buffer for large diffs; we'll cap in the caller
+            maxBuffer: FULL_DIFF_MAX_BYTES + 64 * 1024,
+        });
+        return result;
+    }
+    catch (err) {
+        return { error: err };
+    }
+}
+/** Returns true if the error message indicates git is not installed. */
+function isGitNotInstalled(message) {
+    return (message.includes('command not found') ||
+        message.includes('ENOENT') ||
+        message.includes('not found') ||
+        message.includes("'git' is not recognized"));
+}
+/** Returns true if the error message indicates this is not a git repository. */
+function isNotAGitRepo(message) {
+    return message.includes('not a git repository') || message.includes('Not a git repository');
+}
+/** Returns true if the error message indicates permission was denied. */
+function isPermissionDenied(message) {
+    return message.includes('Permission denied') || message.includes('EACCES');
+}
+/** Returns true if the error indicates no commits exist yet (empty repo). */
+function isEmptyRepo(stderr) {
+    return (stderr.includes('does not have any commits yet') ||
+        stderr.includes('no commits yet') ||
+        stderr.includes("ambiguous argument 'HEAD'") ||
+        stderr.includes('unknown revision or path'));
+}
+/**
+ * Classify a git error into a structured result type.
+ * Covers: git not installed, not a repo, permission denied, empty repo,
+ * or a generic error with the raw message.
+ */
+function classifyError(errMessage) {
+    if (isGitNotInstalled(errMessage)) {
+        return { status: 'error', message: 'git is not installed or not in PATH' };
+    }
+    if (isNotAGitRepo(errMessage)) {
+        return { status: 'not_found' };
+    }
+    if (isPermissionDenied(errMessage)) {
+        return { status: 'error', message: `Permission denied: ${errMessage}` };
+    }
+    return { status: 'error', message: errMessage.trim() };
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Returns `true` if `workingDir` is inside a git repository.
+ * Returns `false` for non-git directories, missing git, or any error.
+ */
+export async function isGitRepo(workingDir) {
+    const result = await runGit('rev-parse --git-dir', workingDir);
+    if ('error' in result)
+        return false;
+    return result.stdout.trim().length > 0;
+}
+/**
+ * Returns the current branch name for the repository at `workingDir`.
+ *
+ * For a detached HEAD, returns `{ status: 'available', branch: 'HEAD' }`.
+ * For a non-git directory, returns `{ status: 'not_found' }`.
+ */
+export async function getBranch(workingDir) {
+    const result = await runGit('rev-parse --abbrev-ref HEAD', workingDir);
+    if ('error' in result) {
+        const errMsg = result.error.message;
+        // Empty repo: HEAD reference doesn't exist yet
+        if (errMsg.includes('unknown revision') ||
+            errMsg.includes('No such file or directory') ||
+            errMsg.includes('does not have any commits')) {
+            return { status: 'available', branch: 'HEAD' };
+        }
+        return classifyError(errMsg);
+    }
+    const branch = result.stdout.trim();
+    if (!branch) {
+        return { status: 'error', message: 'git rev-parse returned empty output' };
+    }
+    return { status: 'available', branch };
+}
+/**
+ * Returns `true` if the working tree has uncommitted changes (staged or unstaged).
+ * Returns `false` for a clean tree, empty repo, or non-git directory.
+ */
+export async function isDirty(workingDir) {
+    const result = await runGit('status --porcelain', workingDir);
+    if ('error' in result)
+        return false;
+    return result.stdout.trim().length > 0;
+}
+/**
+ * Parses `--stat` output into a `DiffStat`.
+ * Input: the summary line, e.g. "3 files changed, 45 insertions(+), 12 deletions(-)"
+ * Returns zero values if the tree is clean or the line cannot be parsed.
+ *
+ * Exported for direct unit testing.
+ */
+export function parseDiffStatLine(statLine) {
+    const filesMatch = statLine.match(/(\d+)\s+file/);
+    const insertMatch = statLine.match(/(\d+)\s+insertion/);
+    const deleteMatch = statLine.match(/(\d+)\s+deletion/);
+    return {
+        filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+        insertions: insertMatch ? parseInt(insertMatch[1], 10) : 0,
+        deletions: deleteMatch ? parseInt(deleteMatch[1], 10) : 0,
+    };
+}
+/**
+ * Returns diff statistics (files changed, insertions, deletions) for the current
+ * working tree against HEAD (`git diff HEAD --stat`).
+ *
+ * Returns zero-value stats for a clean tree (no changes).
+ */
+export async function getDiffStat(workingDir) {
+    const result = await runGit('diff HEAD --stat', workingDir);
+    if ('error' in result) {
+        const errMsg = result.error.message;
+        if (isEmptyRepo(result.error.message)) {
+            return { status: 'no_commits' };
+        }
+        const classified = classifyError(errMsg);
+        if (classified.status === 'not_found')
+            return { status: 'not_found' };
+        // Also check stderr embedded in error message for empty repo clues
+        return classified;
+    }
+    // git diff exits 0 for both clean and dirty trees
+    const output = result.stdout;
+    const stderr = result.stderr;
+    if (isEmptyRepo(stderr)) {
+        return { status: 'no_commits' };
+    }
+    if (!output.trim()) {
+        // Clean tree — zero changes
+        return {
+            status: 'available',
+            diffStat: { filesChanged: 0, insertions: 0, deletions: 0 },
+        };
+    }
+    // The summary line is the last non-empty line
+    const lines = output.trim().split('\n');
+    const summaryLine = lines[lines.length - 1] ?? '';
+    const diffStat = parseDiffStatLine(summaryLine);
+    return { status: 'available', diffStat };
+}
+/**
+ * Returns the full unified diff for the current working tree against HEAD.
+ * Content is capped at `FULL_DIFF_MAX_BYTES` (500 KB).
+ *
+ * Note: Binary files appear as "Binary files differ" in the output — handled
+ * transparently (no special treatment needed; output is valid UTF-8 text).
+ */
+export async function getFullDiff(workingDir) {
+    const result = await runGit('diff HEAD', workingDir);
+    if ('error' in result) {
+        const errMsg = result.error.message;
+        if (isEmptyRepo(errMsg)) {
+            return { status: 'no_commits' };
+        }
+        const classified = classifyError(errMsg);
+        if (classified.status === 'not_found')
+            return { status: 'not_found' };
+        return classified;
+    }
+    const stderr = result.stderr;
+    if (isEmptyRepo(stderr)) {
+        return { status: 'no_commits' };
+    }
+    const raw = result.stdout;
+    const byteLength = Buffer.byteLength(raw, 'utf8');
+    if (byteLength > FULL_DIFF_MAX_BYTES) {
+        // Truncate at a safe character boundary
+        const truncated = Buffer.from(raw, 'utf8').subarray(0, FULL_DIFF_MAX_BYTES).toString('utf8');
+        return { status: 'truncated', content: truncated, truncated: true };
+    }
+    return { status: 'available', content: raw, truncated: false };
+}
+/**
+ * Returns diff statistics for a PR (diff between origin/<baseBranch> and HEAD).
+ * Uses three-dot syntax to diff from the merge-base.
+ */
+export async function getPRDiffStat(workingDir, baseBranch) {
+    const result = await runGit(`diff --stat origin/${baseBranch}...HEAD`, workingDir);
+    if ('error' in result) {
+        const errMsg = result.error.message;
+        if (isEmptyRepo(errMsg)) {
+            return { status: 'no_commits' };
+        }
+        const classified = classifyError(errMsg);
+        if (classified.status === 'not_found')
+            return { status: 'not_found' };
+        return classified;
+    }
+    const output = result.stdout;
+    const stderr = result.stderr;
+    if (isEmptyRepo(stderr)) {
+        return { status: 'no_commits' };
+    }
+    if (!output.trim()) {
+        return {
+            status: 'available',
+            diffStat: { filesChanged: 0, insertions: 0, deletions: 0 },
+        };
+    }
+    const lines = output.trim().split('\n');
+    const summaryLine = lines[lines.length - 1] ?? '';
+    const diffStat = parseDiffStatLine(summaryLine);
+    return { status: 'available', diffStat };
+}
+/**
+ * Returns the full unified PR diff (diff between origin/<baseBranch> and HEAD).
+ * Uses three-dot syntax to diff from the merge-base.
+ * Content is capped at `FULL_DIFF_MAX_BYTES` (500 KB).
+ */
+export async function getPRDiff(workingDir, baseBranch) {
+    const result = await runGit(`diff origin/${baseBranch}...HEAD`, workingDir);
+    if ('error' in result) {
+        const errMsg = result.error.message;
+        if (isEmptyRepo(errMsg)) {
+            return { status: 'no_commits' };
+        }
+        const classified = classifyError(errMsg);
+        if (classified.status === 'not_found')
+            return { status: 'not_found' };
+        return classified;
+    }
+    const stderr = result.stderr;
+    if (isEmptyRepo(stderr)) {
+        return { status: 'no_commits' };
+    }
+    const raw = result.stdout;
+    const byteLength = Buffer.byteLength(raw, 'utf8');
+    if (byteLength > FULL_DIFF_MAX_BYTES) {
+        const truncated = Buffer.from(raw, 'utf8').subarray(0, FULL_DIFF_MAX_BYTES).toString('utf8');
+        return { status: 'truncated', content: truncated, truncated: true };
+    }
+    return { status: 'available', content: raw, truncated: false };
+}
+/**
+ * Returns the diff for a specific PR by number using `gh pr diff <number>`.
+ * Content is capped at `FULL_DIFF_MAX_BYTES` (500 KB).
+ */
+export async function getPRDiffByNumber(cwd, prNumber) {
+    const repoSlug = await getOriginRepoSlug(cwd);
+    const repoFlag = repoSlug ? ` --repo ${JSON.stringify(repoSlug)}` : '';
+    const result = await runCommand(`gh pr diff ${prNumber}${repoFlag}`, cwd);
+    if ('error' in result) {
+        return { status: 'error', message: result.error.message };
+    }
+    const raw = result.stdout;
+    if (!raw.trim()) {
+        return { status: 'available', content: '', truncated: false };
+    }
+    const byteLength = Buffer.byteLength(raw, 'utf8');
+    if (byteLength > FULL_DIFF_MAX_BYTES) {
+        const truncated = Buffer.from(raw, 'utf8').subarray(0, FULL_DIFF_MAX_BYTES).toString('utf8');
+        return { status: 'truncated', content: truncated, truncated: true };
+    }
+    return { status: 'available', content: raw, truncated: false };
+}
+/**
+ * Returns up to `count` recent commits from the current branch.
+ * Default: 20 commits. Optional `skip` to paginate (0-based offset).
+ *
+ * Returns an empty array for an empty repository (no commits).
+ * Returns an empty array for non-git directories (does not throw).
+ */
+export async function getRecentCommits(workingDir, count = 20, skip = 0) {
+    // Use a null-byte separator to safely handle multi-line messages
+    const format = '%H%x00%h%x00%s%x00%an%x00%aI';
+    const skipArg = skip > 0 ? ` --skip=${skip}` : '';
+    const result = await runGit(`log -${count}${skipArg} --format=${format}`, workingDir);
+    if ('error' in result) {
+        // Empty repo or non-git directory — return empty list, not an error
+        return [];
+    }
+    const output = result.stdout.trim();
+    if (!output)
+        return [];
+    const commits = [];
+    for (const line of output.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const parts = trimmed.split('\x00');
+        if (parts.length !== 5)
+            continue;
+        const [sha, shortSha, message, author, date] = parts;
+        commits.push({ sha, shortSha, message, author, date });
+    }
+    return commits;
+}
+/**
+ * Returns the full diff for a specific commit SHA (`git show <sha>`).
+ * Content is capped at `FULL_DIFF_MAX_BYTES` (500 KB).
+ *
+ * Returns `{ status: 'not_found' }` if the SHA does not exist in the
+ * repository, or if the repository has no commits yet (empty repo).
+ */
+export async function getCommitDetail(workingDir, sha) {
+    // --format="" suppresses the commit header; we only want the diff
+    const result = await runGit(`show ${sha} --format="" --stat -p`, workingDir);
+    if ('error' in result) {
+        const errMsg = result.error.message;
+        // Non-git directory: return not_found
+        const classified = classifyError(errMsg);
+        if (classified.status === 'not_found')
+            return { status: 'not_found' };
+        // Empty repo or non-existent SHA → not_found.
+        // Distinguishing "sha doesn't exist" from "no commits yet" is not useful to callers.
+        if (isEmptyRepo(errMsg) ||
+            errMsg.includes('unknown revision') ||
+            errMsg.includes('bad object') ||
+            errMsg.includes('does not exist')) {
+            return { status: 'not_found' };
+        }
+        return classified;
+    }
+    const raw = result.stdout;
+    const byteLength = Buffer.byteLength(raw, 'utf8');
+    if (byteLength > FULL_DIFF_MAX_BYTES) {
+        const truncated = Buffer.from(raw, 'utf8').subarray(0, FULL_DIFF_MAX_BYTES).toString('utf8');
+        return { status: 'truncated', content: truncated, truncated: true };
+    }
+    return { status: 'available', content: raw, truncated: false };
+}
+/**
+ * Returns commit metadata (message, author, date) for a specific SHA.
+ *
+ * Uses `git log -1 --format=...` with null-byte separators for safe parsing.
+ * Returns `null` if the SHA is not found or the directory is not a git repo.
+ */
+export async function getCommitMetadata(workingDir, sha) {
+    const format = '%s%x00%an%x00%aI';
+    const result = await runGit(`log -1 --format=${format} ${sha}`, workingDir);
+    if ('error' in result)
+        return null;
+    const output = result.stdout.trim();
+    if (!output)
+        return null;
+    const parts = output.split('\x00');
+    if (parts.length !== 3)
+        return null;
+    return { message: parts[0], author: parts[1], date: parts[2] };
+}
+// ─── GitHub CLI Integration ──────────────────────────────────────────────────
+/**
+ * Run an arbitrary command in `cwd`.
+ * Returns `{ stdout, stderr }` on success, `{ error }` on failure.
+ * Never throws.
+ */
+async function runCommand(command, cwd) {
+    try {
+        const result = await execAsync(command, {
+            cwd,
+            env: { ...process.env, NO_COLOR: '1' },
+            timeout: 15_000, // 15s timeout for gh commands
+        });
+        return result;
+    }
+    catch (err) {
+        return { error: err };
+    }
+}
+/**
+ * Parse a git remote URL into an `owner/repo` slug.
+ * Handles both HTTPS and SSH URL formats, with or without `.git` suffix.
+ *
+ * Examples:
+ *   https://github.com/owner/repo.git → owner/repo
+ *   https://github.com/owner/repo     → owner/repo
+ *   git@github.com:owner/repo.git     → owner/repo
+ *   git@github.com:owner/repo         → owner/repo
+ *
+ * Returns `null` if the URL cannot be parsed.
+ *
+ * Exported for unit testing.
+ */
+export function parseRepoSlug(remoteUrl) {
+    const trimmed = remoteUrl.trim();
+    // HTTPS format: https://github.com/owner/repo.git or https://github.com/owner/repo
+    const httpsMatch = trimmed.match(/https?:\/\/[^/]+\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (httpsMatch && httpsMatch[1] && httpsMatch[2]) {
+        return `${httpsMatch[1]}/${httpsMatch[2]}`;
+    }
+    // SSH format: git@github.com:owner/repo.git or git@github.com:owner/repo
+    const sshMatch = trimmed.match(/git@[^:]+:([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (sshMatch && sshMatch[1] && sshMatch[2]) {
+        return `${sshMatch[1]}/${sshMatch[2]}`;
+    }
+    return null;
+}
+/**
+ * Get the `owner/repo` slug for the `origin` remote of the repository at `cwd`.
+ *
+ * Returns `null` if:
+ * - The `origin` remote does not exist
+ * - The URL cannot be parsed
+ * - Any error occurs (graceful degradation)
+ *
+ * Exported for unit testing.
+ */
+export async function getOriginRepoSlug(cwd) {
+    const result = await runGit('remote get-url origin', cwd);
+    if ('error' in result)
+        return null;
+    const url = result.stdout.trim();
+    if (!url)
+        return null;
+    return parseRepoSlug(url);
+}
+/**
+ * Get open pull requests for the given branch using `gh pr list`.
+ *
+ * Returns an empty array if:
+ * - The `gh` CLI is not installed
+ * - The user is not authenticated with `gh`
+ * - There are no open PRs for the branch
+ * - Any error occurs (graceful degradation)
+ */
+export async function getOpenPRsForBranch(cwd, branch) {
+    // Resolve the origin repo slug to target the correct repository
+    const repoSlug = await getOriginRepoSlug(cwd);
+    const repoFlag = repoSlug ? ` --repo ${JSON.stringify(repoSlug)}` : '';
+    // Extract owner from repo slug (e.g., 'owner/repo' → 'owner')
+    const repoOwner = repoSlug?.split('/')[0] ?? null;
+    const result = await runCommand(`gh pr list --head ${JSON.stringify(branch)} --state open --author @me --json number,title,url,headRefName,state,headRepositoryOwner --limit 5${repoFlag}`, cwd);
+    if ('error' in result) {
+        // gh not installed, not authenticated, or other failure — degrade gracefully
+        return [];
+    }
+    const output = result.stdout.trim();
+    if (!output)
+        return [];
+    try {
+        const parsed = JSON.parse(output);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .filter((item) => typeof item === 'object' &&
+            item !== null &&
+            typeof item.number === 'number' &&
+            typeof item.title === 'string' &&
+            typeof item.url === 'string' &&
+            typeof item.headRefName === 'string' &&
+            typeof item.state === 'string')
+            .filter((item) => {
+            // Filter out cross-fork PRs: only include PRs from the same repo owner
+            // This prevents PRs from forks (e.g., fork's main → upstream's main) from showing
+            if (!repoOwner || !item.headRepositoryOwner?.login)
+                return true;
+            return item.headRepositoryOwner.login === repoOwner;
+        })
+            .map((item) => ({
+            number: item.number,
+            title: item.title,
+            url: item.url,
+            headRefName: item.headRefName,
+            state: item.state,
+        }));
+    }
+    catch {
+        // JSON parse failure — degrade gracefully
+        return [];
+    }
+}
+function isGHPRItem(item) {
+    return (typeof item === 'object' &&
+        item !== null &&
+        typeof item.number === 'number' &&
+        typeof item.title === 'string');
+}
+/**
+ * Get all pull requests (open, closed, merged) for the repository using `gh pr list`.
+ * Returns up to 20 most recent PRs.
+ */
+export async function getAllPRs(cwd) {
+    const repoSlug = await getOriginRepoSlug(cwd);
+    const repoFlag = repoSlug ? ` --repo ${JSON.stringify(repoSlug)}` : '';
+    const result = await runCommand(`gh pr list --limit 20 --state all --json number,title,state,headRefName,baseRefName,url,author,createdAt,updatedAt,mergedAt,closedAt,isDraft${repoFlag}`, cwd);
+    if ('error' in result) {
+        return [];
+    }
+    const output = result.stdout.trim();
+    if (!output)
+        return [];
+    try {
+        const parsed = JSON.parse(output);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .filter(isGHPRItem)
+            .map((item) => {
+            const author = typeof item.author === 'object' && item.author !== null
+                ? item.author.login
+                : undefined;
+            return {
+                number: item.number,
+                title: item.title,
+                url: item.url ?? '',
+                headRefName: item.headRefName ?? '',
+                baseRefName: item.baseRefName ?? 'main',
+                state: item.state ?? 'OPEN',
+                author,
+                createdAt: item.createdAt ?? undefined,
+                updatedAt: item.updatedAt ?? undefined,
+                mergedAt: item.mergedAt ?? null,
+                closedAt: item.closedAt ?? null,
+                isDraft: item.isDraft ?? false,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get the list of commits for a specific PR number.
+ * Uses `gh pr view <number> --json commits`.
+ */
+export async function getPRCommits(cwd, prNumber) {
+    const repoSlug = await getOriginRepoSlug(cwd);
+    const repoFlag = repoSlug ? ` --repo ${JSON.stringify(repoSlug)}` : '';
+    const result = await runCommand(`gh pr view ${prNumber} --json commits${repoFlag}`, cwd);
+    if ('error' in result) {
+        return [];
+    }
+    const output = result.stdout.trim();
+    if (!output)
+        return [];
+    try {
+        const parsed = JSON.parse(output);
+        if (typeof parsed !== 'object' || parsed === null || !('commits' in parsed))
+            return [];
+        const commits = parsed.commits;
+        if (!Array.isArray(commits))
+            return [];
+        return commits.map((c) => {
+            const commit = c;
+            const oid = typeof commit.oid === 'string' ? commit.oid : '';
+            const headline = typeof commit.messageHeadline === 'string' ? commit.messageHeadline : '';
+            const date = typeof commit.committedDate === 'string' ? commit.committedDate : '';
+            // Authors array
+            let authorLogin = '';
+            if (Array.isArray(commit.authors) && commit.authors.length > 0) {
+                const first = commit.authors[0];
+                authorLogin = typeof first.login === 'string' ? first.login : (typeof first.name === 'string' ? first.name : '');
+            }
+            return {
+                sha: oid,
+                shortSha: oid.slice(0, 7),
+                message: headline,
+                author: authorLogin,
+                date,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get all configured git remotes for the repository at `cwd`.
+ *
+ * Runs `git remote -v` and deduplicates (keeping fetch entries).
+ * Returns an empty array if no remotes are configured or the command fails.
+ */
+export async function getRemotes(cwd) {
+    const result = await runGit('remote -v', cwd);
+    if ('error' in result)
+        return [];
+    if (!result.stdout.trim())
+        return [];
+    const lines = result.stdout.trim().split('\n');
+    const seen = new Set();
+    const remotes = [];
+    for (const line of lines) {
+        // Format: "origin\thttps://github.com/user/repo.git (fetch)"
+        const match = line.match(/^(\S+)\s+(\S+)\s+\((\w+)\)$/);
+        if (!match)
+            continue;
+        const [, name, url, type] = match;
+        if (!name || !url)
+            continue;
+        // Deduplicate — prefer fetch entry (listed first)
+        if (type === 'fetch' && !seen.has(name)) {
+            seen.add(name);
+            remotes.push({ name, url });
+        }
+    }
+    return remotes;
+}
+/**
+ * Returns the number of commits on the current branch that are ahead of the
+ * tracking remote branch (i.e. unpushed commits).
+ *
+ * Uses `git rev-list --count @{upstream}..HEAD` which counts commits reachable
+ * from HEAD but not from the upstream tracking branch.
+ *
+ * Returns 0 if:
+ *  - There is no upstream configured for the current branch
+ *  - The repository has no commits
+ *  - The directory is not a git repository
+ *  - Any other error occurs
+ *
+ * This is intentionally lenient — unpushed count is supplementary info and
+ * should never cause the git state push to fail.
+ */
+export async function getCommitsAhead(workingDir) {
+    const result = await runGit('rev-list --count @{upstream}..HEAD', workingDir);
+    if ('error' in result)
+        return 0;
+    const count = parseInt(result.stdout.trim(), 10);
+    return Number.isNaN(count) ? 0 : count;
+}
+/**
+ * Get CI/CD commit status checks for a given ref (branch or SHA).
+ *
+ * Uses `gh api` to fetch check runs and combined commit status.
+ * Returns null if `gh` is unavailable or any error occurs (non-blocking).
+ */
+export async function getCommitStatusChecks(cwd, ref) {
+    const repoSlug = await getOriginRepoSlug(cwd);
+    if (!repoSlug)
+        return null;
+    try {
+        // Fetch check runs and combined status in parallel
+        const [checkRunsResult, statusResult] = await Promise.all([
+            runCommand(`gh api repos/${repoSlug}/commits/${encodeURIComponent(ref)}/check-runs --jq '{check_runs: [.check_runs[] | {name: .name, status: .status, conclusion: .conclusion}], total_count: .total_count}'`, cwd),
+            runCommand(`gh api repos/${repoSlug}/commits/${encodeURIComponent(ref)}/status --jq '.state'`, cwd),
+        ]);
+        if ('error' in checkRunsResult || 'error' in statusResult)
+            return null;
+        const checkRunsData = JSON.parse(checkRunsResult.stdout.trim());
+        const combinedState = statusResult.stdout.trim() || 'pending';
+        // Determine overall state: prefer check runs conclusion over legacy status API
+        let state = combinedState;
+        if (checkRunsData.total_count > 0) {
+            const conclusions = checkRunsData.check_runs.map((cr) => cr.conclusion);
+            if (conclusions.some((c) => c === 'failure' || c === 'timed_out')) {
+                state = 'failure';
+            }
+            else if (conclusions.every((c) => c === 'success' || c === 'skipped' || c === 'neutral')) {
+                state = 'success';
+            }
+            else if (checkRunsData.check_runs.some((cr) => cr.status !== 'completed')) {
+                state = 'pending';
+            }
+        }
+        return {
+            state,
+            checkRuns: checkRunsData.check_runs.map((cr) => ({
+                name: cr.name,
+                status: cr.status,
+                conclusion: cr.conclusion,
+            })),
+            totalCount: checkRunsData.total_count,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the default branch name for the repository (e.g. 'main', 'master').
+ *
+ * Uses `gh api` to query the repo metadata.
+ * Returns null if `gh` is unavailable or any error occurs.
+ */
+export async function getDefaultBranch(cwd) {
+    const repoSlug = await getOriginRepoSlug(cwd);
+    if (!repoSlug)
+        return null;
+    try {
+        const result = await runCommand(`gh api repos/${repoSlug} --jq '.default_branch'`, cwd);
+        if ('error' in result)
+            return null;
+        const branch = result.stdout.trim();
+        return branch || null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=git-reader.js.map