@senad-d/branchme 0.1.5 → 0.1.7

package/src/constants.ts

@@ -4,22 +4,29 @@ export const BRANCHME_COMMAND_NAME = "branchme";
 export const BRANCH_STATUS_TOOL_NAME = "branch_status";
 export const CREATE_BRANCH_TOOL_NAME = "create_branch";
 export const CHANGE_BRANCH_TOOL_NAME = "change_branch";
+export const FETCH_BRANCH_TOOL_NAME = "fetch_branch";
 export const PULL_BRANCH_TOOL_NAME = "pull_branch";
+export const REBASE_BRANCH_TOOL_NAME = "rebase_branch";
 export const PUSH_BRANCH_TOOL_NAME = "push_branch";
 export const PULL_REQUEST_TOOL_NAME = "pull_request";
+export const PULL_REQUEST_AUTOFILL_ENV_NAME = "BRANCHME_PR_AUTOFILL";
 
 export const BRANCHME_TOOL_NAMES = [
   BRANCH_STATUS_TOOL_NAME,
   CREATE_BRANCH_TOOL_NAME,
   CHANGE_BRANCH_TOOL_NAME,
+  FETCH_BRANCH_TOOL_NAME,
   PULL_BRANCH_TOOL_NAME,
+  REBASE_BRANCH_TOOL_NAME,
   PUSH_BRANCH_TOOL_NAME,
   PULL_REQUEST_TOOL_NAME,
 ] as const;
 
 export const GIT_STATUS_TIMEOUT_MS = 5_000;
 export const GIT_MUTATION_TIMEOUT_MS = 30_000;
+export const GIT_FETCH_TIMEOUT_MS = 120_000;
 export const GIT_PULL_TIMEOUT_MS = 120_000;
+export const GIT_REBASE_TIMEOUT_MS = 120_000;
 export const GIT_PUSH_TIMEOUT_MS = 120_000;
 export const GITHUB_RELATED_PR_TIMEOUT_MS = 4_000;
 
@@ -27,6 +34,8 @@ export const GIT_CONTEXT_RECENT_COMMIT_LIMIT = 5;
 export const GIT_CONTEXT_CHANGE_LIMIT = 20;
 export const GIT_CONTEXT_VALUE_LIMIT_CHARS = 512;
 export const GIT_CONTEXT_SUMMARY_LIMIT_CHARS = 4_000;
+export const PULL_REQUEST_AUTOFILL_COMMIT_LIMIT = 20;
+export const PULL_REQUEST_AUTOFILL_SUBJECT_LIMIT_CHARS = 256;
 
 export const GITHUB_API_BASE_URL = "https://api.github.com";
 export const GITHUB_API_VERSION = "2022-11-28";

package/src/git-context.ts

@@ -19,7 +19,7 @@ import {
   getWorkingTreeStatus,
   type GitCommandContext,
 } from "./git.ts";
-import { lookupRelatedPullRequest } from "./github.ts";
+import { lookupRelatedPullRequest, resolvePullRequestAutofill } from "./github.ts";
 import { redactSecrets } from "./redaction.ts";
 import type { GitContextDetails, GitFileChange, RecentCommit, RelatedPullRequest } from "./types.ts";
 
@@ -138,6 +138,7 @@ export async function collectGitContext(
   const recentCommits = await getRecentCommits(pi, rootCtx, options.signal);
   const upstream = current.detached ? null : await getUpstreamBranch(pi, rootCtx, options.signal);
   const warnings: string[] = [];
+  let pullRequestAutofill: boolean | null = null;
   let ahead: number | null = null;
   let behind: number | null = null;
 
@@ -152,6 +153,13 @@ export async function collectGitContext(
     }
   }
 
+  try {
+    pullRequestAutofill = await resolvePullRequestAutofill(options.env, { cwd: repoRoot, signal: options.signal });
+  } catch (error) {
+    throwIfCollectionAborted(options.signal);
+    warnings.push(`pull request autofill configuration unavailable (${safeFailureType(error)})`);
+  }
+
   const relatedPullRequest = await collectRelatedPullRequest(pi, rootCtx, options);
 
   return {
@@ -166,6 +174,7 @@ export async function collectGitContext(
     ...(relatedPullRequest.status === "found"
       ? { githubRepository: relatedPullRequest.pullRequest.repository }
       : {}),
+    pullRequestAutofill,
     workingTree: workingTreeStatus.workingTree,
     unstagedChanges: workingTreeStatus.unstagedChanges,
     relatedPullRequest,
@@ -223,6 +232,13 @@ function formatRelatedPullRequest(details: GitContextDetails, valueLimit: number
   return `- Related PR: #${safeNonNegativeInteger(pullRequest.number)} ${quoteMetadata(pullRequest.title, valueLimit)}; repository ${quoteMetadata(repository, valueLimit)}; ${quoteMetadata(pullRequest.head, valueLimit)} -> ${quoteMetadata(pullRequest.base, valueLimit)}; ${quoteMetadata(pullRequest.url, valueLimit)}; ${quoteMetadata(pullRequest.state, valueLimit)}${draft}`;
 }
 
+function formatPullRequestAutofill(details: GitContextDetails): string {
+  let state = "unavailable";
+  if (details.pullRequestAutofill === true) state = "enabled";
+  if (details.pullRequestAutofill === false) state = "disabled";
+  return `- Pull request field autofill: ${state} (BRANCHME_PR_AUTOFILL)`;
+}
+
 function appendRecentCommits(lines: string[], selection: FormatSelection): void {
   if (selection.commits.length === 0 && selection.omittedCommits === 0) {
     lines.push("- Recent commits: none");
@@ -257,7 +273,10 @@ function renderGitContext(
     formatWorkingTree(details),
   ];
   appendUnstagedChanges(lines, selection);
-  lines.push(formatRelatedPullRequest(details, selection.valueLimit));
+  lines.push(
+    formatRelatedPullRequest(details, selection.valueLimit),
+    formatPullRequestAutofill(details),
+  );
   appendRecentCommits(lines, selection);
   lines.push(
     "",
@@ -295,6 +314,7 @@ function boundedFallbackContext(mode: GitContextFormatMode): string {
     "- Working tree: unavailable",
     "- Unstaged changes: [entries omitted]",
     "- Related PR: unavailable",
+    "- Pull request field autofill: unavailable",
     "- Recent commits: [entries omitted]",
     "",
     "Call branch_status to request a current bounded snapshot.",

package/src/git.ts

@@ -3,11 +3,15 @@ import {
   GIT_CONTEXT_CHANGE_LIMIT,
   GIT_CONTEXT_RECENT_COMMIT_LIMIT,
   GIT_CONTEXT_VALUE_LIMIT_CHARS,
+  GIT_FETCH_TIMEOUT_MS,
   GIT_MUTATION_TIMEOUT_MS,
   GIT_PULL_TIMEOUT_MS,
   GIT_PUSH_TIMEOUT_MS,
+  GIT_REBASE_TIMEOUT_MS,
   GIT_STATUS_TIMEOUT_MS,
   MAX_SUMMARY_OUTPUT_CHARS,
+  PULL_REQUEST_AUTOFILL_COMMIT_LIMIT,
+  PULL_REQUEST_AUTOFILL_SUBJECT_LIMIT_CHARS,
 } from "./constants.ts";
 import { redactSecrets } from "./redaction.ts";
 import type {
@@ -16,11 +20,13 @@ import type {
   ChangeBranchDetails,
   CreateBranchDetails,
   CurrentBranchInfo,
+  FetchBranchDetails,
   GitExecResult,
   GitFileChange,
   GitFileChangeSummary,
   PullBranchDetails,
   PushBranchDetails,
+  RebaseBranchDetails,
   RecentCommit,
   WorkingTreeDetails,
 } from "./types.ts";
@@ -33,6 +39,7 @@ export interface GitRunOptions {
   signal?: AbortSignal;
   timeout?: number;
   allowFailure?: boolean;
+  tokens?: readonly string[];
 }
 
 const repositoryMutationQueues = new Map<string, Promise<void>>();
@@ -110,11 +117,11 @@ export async function runGit(
   });
 
   if (result.killed) {
-    throw new Error(formatGitFailure(args, result));
+    throw new Error(formatGitFailure(args, result, options.tokens));
   }
 
   if (!options.allowFailure && result.code !== 0) {
-    throw new Error(formatGitFailure(args, result));
+    throw new Error(formatGitFailure(args, result, options.tokens));
   }
 
   return result;
@@ -199,7 +206,7 @@ interface PushTarget {
   args: string[];
 }
 
-type UpstreamOperation = "pull" | "push";
+type UpstreamOperation = "fetch" | "pull" | "push" | "rebase";
 
 function validateRemoteName(remote: string, operation: UpstreamOperation): void {
   if (!remote) throw new Error(`Unable to ${operation} current branch: upstream remote is missing.`);
@@ -241,6 +248,17 @@ async function getBranchConfigValue(
   return value || null;
 }
 
+function remoteTrackingRef(upstream: string, remote: string): string {
+  const prefix = `${remote}/`;
+  if (!upstream.startsWith(prefix)) {
+    throw new Error("Unable to fetch current branch: configured upstream does not match its remote.");
+  }
+
+  const trackingBranch = upstream.slice(prefix.length);
+  validateBranchNameInput(trackingBranch, "Upstream branch name");
+  return `refs/remotes/${upstream}`;
+}
+
 async function resolveConfiguredUpstreamTarget(
   pi: Pick<ExtensionAPI, "exec">,
   ctx: GitCommandContext,
@@ -553,6 +571,98 @@ export async function getRecentCommits(
   throw new Error(formatGitFailure(args, result));
 }
 
+function truncatePullRequestCommitSubject(value: string): string {
+  if (value.length <= PULL_REQUEST_AUTOFILL_SUBJECT_LIMIT_CHARS) return value;
+
+  let end = PULL_REQUEST_AUTOFILL_SUBJECT_LIMIT_CHARS - 1;
+  const lastCodePoint = value.codePointAt(end - 1);
+  if (lastCodePoint !== undefined && lastCodePoint > 0xffff) end -= 1;
+  return `${value.slice(0, end).trimEnd()}…`;
+}
+
+function safePullRequestCommitSubject(value: string, tokens: readonly string[]): string {
+  const normalized = redactSecrets(value, tokens)
+    .replace(/[\p{Cc}\p{Cf}\u2028\u2029]/gu, " ")
+    .replace(/\s+/gu, " ")
+    .trim();
+  return truncatePullRequestCommitSubject(normalized);
+}
+
+async function getOriginDefaultBranch(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  const args = ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"];
+  const result = await runGit(pi, ctx, args, {
+    signal,
+    timeout: GIT_STATUS_TIMEOUT_MS,
+    allowFailure: true,
+  });
+  if (result.code !== 0) return null;
+
+  const remoteBranch = trimOutput(result.stdout);
+  const prefix = "origin/";
+  if (!remoteBranch.startsWith(prefix)) return null;
+
+  const branch = remoteBranch.slice(prefix.length);
+  try {
+    validateBranchNameInput(branch, "Default base branch");
+  } catch {
+    return null;
+  }
+  return branch;
+}
+
+export async function inferPullRequestBaseBranch(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  headBranch: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  validateBranchNameInput(headBranch, "headBranch");
+  const originDefault = await getOriginDefaultBranch(pi, ctx, signal);
+  if (originDefault) {
+    if (originDefault === headBranch) {
+      throw new Error("Unable to infer baseBranch because the current branch is the origin default branch.");
+    }
+    if (await localBranchExists(pi, ctx, originDefault, signal)) return originDefault;
+  }
+
+  for (const candidate of ["main", "master", "trunk", "develop"]) {
+    if (candidate !== headBranch && await localBranchExists(pi, ctx, candidate, signal)) return candidate;
+  }
+
+  throw new Error(
+    "Unable to infer baseBranch from origin/HEAD or a local main, master, trunk, or develop branch; provide baseBranch explicitly.",
+  );
+}
+
+export async function getPullRequestCommitSubjects(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  headBranch: string,
+  baseBranch: string,
+  signal?: AbortSignal,
+  tokens: readonly string[] = [],
+): Promise<string[]> {
+  validateBranchNameInput(headBranch, "headBranch");
+  validateBranchNameInput(baseBranch, "baseBranch");
+  const revisionRange = `refs/heads/${baseBranch}..refs/heads/${headBranch}`;
+  const args = [
+    "log",
+    `--max-count=${PULL_REQUEST_AUTOFILL_COMMIT_LIMIT}`,
+    "--format=%s",
+    revisionRange,
+    "--",
+  ];
+  const result = await runGit(pi, ctx, args, { signal, timeout: GIT_STATUS_TIMEOUT_MS, tokens });
+  return result.stdout
+    .split(/\r?\n/u)
+    .map((subject) => safePullRequestCommitSubject(subject, tokens))
+    .filter(Boolean);
+}
+
 export async function getAheadBehindCount(
   pi: Pick<ExtensionAPI, "exec">,
   ctx: GitCommandContext,
@@ -700,6 +810,46 @@ export async function changeExistingLocalBranch(
   });
 }
 
+export async function fetchCurrentBranch(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  signal?: AbortSignal,
+): Promise<FetchBranchDetails> {
+  const repoRoot = await getGitRoot(pi, ctx, signal);
+  const rootCtx = { cwd: repoRoot };
+
+  return withRepositoryMutationQueue(repoRoot, async () => {
+    const currentBranch = await requireCurrentBranch(pi, rootCtx, signal);
+    const target = await resolveConfiguredUpstreamTarget(pi, rootCtx, currentBranch, "fetch", signal);
+    if (!target) {
+      throw new Error(`Unable to fetch current branch '${safeDetail(currentBranch)}': no upstream is configured.`);
+    }
+
+    const trackingRef = remoteTrackingRef(target.upstream, target.remote);
+    const refspec = `${target.remoteRef}:${trackingRef}`;
+    const result = await runGit(
+      pi,
+      rootCtx,
+      ["fetch", "--no-tags", "--no-recurse-submodules", target.remote, refspec],
+      {
+        signal,
+        timeout: GIT_FETCH_TIMEOUT_MS,
+      },
+    );
+
+    return {
+      repoRoot,
+      currentBranch: safeDetail(currentBranch),
+      upstream: safeDetail(target.upstream),
+      remote: safeDetail(target.remote),
+      remoteRef: safeDetail(target.remoteRef),
+      remoteTrackingRef: safeDetail(trackingRef),
+      refspec: safeDetail(refspec),
+      output: safeOutput(result.stdout || result.stderr),
+    };
+  });
+}
+
 export async function pullCurrentBranch(
   pi: Pick<ExtensionAPI, "exec">,
   ctx: GitCommandContext,
@@ -735,6 +885,78 @@ export async function pullCurrentBranch(
   });
 }
 
+async function abortFailedRebase(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  failureMessage: string,
+): Promise<never> {
+  const abortArgs = ["rebase", "--abort"];
+  let abortResult: GitExecResult;
+  try {
+    abortResult = await runGit(pi, ctx, abortArgs, {
+      timeout: GIT_MUTATION_TIMEOUT_MS,
+      allowFailure: true,
+    });
+  } catch (error) {
+    const reason = safeOutput(error instanceof Error ? error.message : String(error)) || "git rebase --abort failed";
+    throw new Error(`${failureMessage}. Automatic rebase cleanup failed: ${reason}. Inspect the repository before continuing.`);
+  }
+
+  if (abortResult.code === 0) {
+    throw new Error(`${failureMessage}. Rebase was aborted and the current branch was restored.`);
+  }
+
+  const reason = safeOutput(abortResult.stderr || abortResult.stdout) || `exit code ${abortResult.code}`;
+  throw new Error(`${failureMessage}. Automatic git rebase --abort did not complete: ${reason}. Inspect the repository before continuing.`);
+}
+
+export async function rebaseCurrentBranch(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  signal?: AbortSignal,
+): Promise<RebaseBranchDetails> {
+  const repoRoot = await getGitRoot(pi, ctx, signal);
+  const rootCtx = { cwd: repoRoot };
+
+  return withRepositoryMutationQueue(repoRoot, async () => {
+    const currentBranch = await requireCurrentBranch(pi, rootCtx, signal);
+    if (await hasWorkingTreeChanges(pi, rootCtx, signal)) {
+      throw new Error("Working tree has uncommitted changes; clean it before rebasing the current branch.");
+    }
+
+    const target = await resolveConfiguredUpstreamTarget(pi, rootCtx, currentBranch, "rebase", signal);
+    if (!target) {
+      throw new Error(`Unable to rebase current branch '${safeDetail(currentBranch)}': no upstream is configured.`);
+    }
+
+    const args = ["rebase", "--no-autostash", "--no-update-refs", target.upstream];
+    let result: GitExecResult;
+    try {
+      result = await runGit(pi, rootCtx, args, {
+        signal,
+        timeout: GIT_REBASE_TIMEOUT_MS,
+        allowFailure: true,
+      });
+    } catch (error) {
+      const failureMessage = safeOutput(error instanceof Error ? error.message : String(error)) || "git rebase failed";
+      return abortFailedRebase(pi, rootCtx, failureMessage);
+    }
+
+    if (result.code !== 0) {
+      return abortFailedRebase(pi, rootCtx, formatGitFailure(args, result));
+    }
+
+    return {
+      repoRoot,
+      currentBranch: safeDetail(currentBranch),
+      upstream: safeDetail(target.upstream),
+      remote: safeDetail(target.remote),
+      remoteRef: safeDetail(target.remoteRef),
+      output: safeOutput(result.stdout || result.stderr),
+    };
+  });
+}
+
 export async function pushCurrentBranch(
   pi: Pick<ExtensionAPI, "exec">,
   ctx: GitCommandContext,

package/src/github.ts

@@ -10,6 +10,7 @@ import {
   GITHUB_USER_AGENT,
   GIT_CONTEXT_VALUE_LIMIT_CHARS,
   MAX_SUMMARY_OUTPUT_CHARS,
+  PULL_REQUEST_AUTOFILL_ENV_NAME,
 } from "./constants.ts";
 import {
   getCurrentBranch,
@@ -27,6 +28,9 @@ import type {
 } from "./types.ts";
 
 type TokenEnvironmentKey = "GITHUB_TOKEN" | "GH_TOKEN";
+type PullRequestAutofillEnvironmentKey = typeof PULL_REQUEST_AUTOFILL_ENV_NAME;
+type SupportedDotEnvKey = TokenEnvironmentKey | PullRequestAutofillEnvironmentKey;
+type DotEnvReadPurpose = "GitHub token fallback" | "pull request autofill configuration";
 
 export type TokenResolutionSource = TokenEnvironmentKey | `${TokenEnvironmentKey} (.env)`;
 
@@ -149,8 +153,8 @@ function resolveProcessToken(env: NodeJS.ProcessEnv): TokenResolution | null {
   return null;
 }
 
-function isTokenEnvironmentKey(value: string): value is TokenEnvironmentKey {
-  return value === "GITHUB_TOKEN" || value === "GH_TOKEN";
+function isSupportedDotEnvKey(value: string): value is SupportedDotEnvKey {
+  return value === "GITHUB_TOKEN" || value === "GH_TOKEN" || value === PULL_REQUEST_AUTOFILL_ENV_NAME;
 }
 
 function decodeDoubleQuotedDotEnvValue(value: string): string {
@@ -182,23 +186,46 @@ function stripDotEnvInlineComment(value: string): string {
   return value;
 }
 
+function closingDotEnvQuoteIndex(value: string, quote: "\"" | "'"): number {
+  let escaped = false;
+  for (let index = 1; index < value.length; index += 1) {
+    const character = value.charAt(index);
+    if (quote === "\"" && character === "\\" && !escaped) {
+      escaped = true;
+      continue;
+    }
+    if (character === quote && !escaped) return index;
+    escaped = false;
+  }
+  return -1;
+}
+
+function parseQuotedDotEnvValue(value: string): string | null {
+  const quote = value.charAt(0);
+  if (quote !== "\"" && quote !== "'") return null;
+
+  const closingIndex = closingDotEnvQuoteIndex(value, quote);
+  if (closingIndex === -1) return null;
+
+  const remainder = value.slice(closingIndex + 1).trim();
+  if (remainder && !remainder.startsWith("#")) return null;
+
+  const quotedValue = value.slice(1, closingIndex);
+  return quote === "\"" ? decodeDoubleQuotedDotEnvValue(quotedValue).trim() : quotedValue.trim();
+}
+
 function parseDotEnvValue(rawValue: string): string {
   const value = rawValue.trim();
   if (!value) return "";
 
-  if (value.startsWith("\"") && value.endsWith("\"")) {
-    return decodeDoubleQuotedDotEnvValue(value.slice(1, -1)).trim();
-  }
-
-  if (value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1).trim();
-  }
+  const quotedValue = parseQuotedDotEnvValue(value);
+  if (quotedValue !== null) return quotedValue;
 
   return stripDotEnvInlineComment(value).trim();
 }
 
-function parseDotEnvTokens(contents: string): Partial<Record<TokenEnvironmentKey, string>> {
-  const tokens: Partial<Record<TokenEnvironmentKey, string>> = {};
+function parseDotEnvValues(contents: string): Partial<Record<SupportedDotEnvKey, string>> {
+  const values: Partial<Record<SupportedDotEnvKey, string>> = {};
 
   for (const line of contents.split(/\r?\n/u)) {
     const trimmed = line.trim();
@@ -209,12 +236,12 @@ function parseDotEnvTokens(contents: string): Partial<Record<TokenEnvironmentKey
     if (separatorIndex === -1) continue;
 
     const key = assignment.slice(0, separatorIndex).trim();
-    if (!isTokenEnvironmentKey(key)) continue;
+    if (!isSupportedDotEnvKey(key)) continue;
 
-    tokens[key] = parseDotEnvValue(assignment.slice(separatorIndex + 1).trimStart());
+    values[key] = parseDotEnvValue(assignment.slice(separatorIndex + 1).trimStart());
   }
 
-  return tokens;
+  return values;
 }
 
 const MAX_DOTENV_BYTES = 64 * 1024;
@@ -223,55 +250,77 @@ function isMissingFileError(error: unknown): boolean {
   return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
 
-function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) throw new Error("GitHub token .env fallback was aborted.");
+function throwIfAborted(signal: AbortSignal | undefined, purpose: DotEnvReadPurpose): void {
+  if (signal?.aborted) throw new Error(`${purpose} .env read was aborted.`);
 }
 
 function errorMessage(error: unknown): string {
   return redactSecrets(error instanceof Error ? error.message : String(error));
 }
 
-async function readDotEnvTokens(
+async function readDotEnvValues(
   cwd: string | undefined,
   signal?: AbortSignal,
-): Promise<Partial<Record<TokenEnvironmentKey, string>>> {
+  purpose: DotEnvReadPurpose = "GitHub token fallback",
+): Promise<Partial<Record<SupportedDotEnvKey, string>>> {
   if (!cwd) return {};
 
   const envPath = join(cwd, ".env");
-  throwIfAborted(signal);
+  throwIfAborted(signal, purpose);
 
   let stats: Awaited<ReturnType<typeof lstat>>;
   try {
     stats = await lstat(envPath);
   } catch (error) {
     if (isMissingFileError(error)) return {};
-    throw new Error(`Unable to inspect .env file for GitHub token fallback: ${errorMessage(error)}`);
+    throw new Error(`Unable to inspect .env file for ${purpose}: ${errorMessage(error)}`);
   }
 
   if (!stats.isFile()) {
-    throw new Error("Unable to read .env file for GitHub token fallback: .env must be a small regular file.");
+    throw new Error(`Unable to read .env file for ${purpose}: .env must be a small regular file.`);
   }
   if (stats.size > MAX_DOTENV_BYTES) {
     throw new Error(
-      `Unable to read .env file for GitHub token fallback: .env is too large (${stats.size} bytes; limit ${MAX_DOTENV_BYTES} bytes).`,
+      `Unable to read .env file for ${purpose}: .env is too large (${stats.size} bytes; limit ${MAX_DOTENV_BYTES} bytes).`,
     );
   }
 
-  throwIfAborted(signal);
+  throwIfAborted(signal, purpose);
 
   let contents: string;
   try {
     contents = await readFile(envPath, { encoding: "utf8", signal });
   } catch (error) {
     if (isMissingFileError(error)) return {};
-    throw new Error(`Unable to read .env file for GitHub token fallback: ${errorMessage(error)}`);
+    throw new Error(`Unable to read .env file for ${purpose}: ${errorMessage(error)}`);
   }
 
   if (Buffer.byteLength(contents, "utf8") > MAX_DOTENV_BYTES) {
-    throw new Error(`Unable to read .env file for GitHub token fallback: .env exceeded the ${MAX_DOTENV_BYTES} byte limit.`);
+    throw new Error(`Unable to read .env file for ${purpose}: .env exceeded the ${MAX_DOTENV_BYTES} byte limit.`);
   }
 
-  return parseDotEnvTokens(contents);
+  return parseDotEnvValues(contents);
+}
+
+function parsePullRequestAutofillValue(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  throw new Error(
+    `${PULL_REQUEST_AUTOFILL_ENV_NAME} must be one of true, false, 1, 0, yes, no, on, or off.`,
+  );
+}
+
+export async function resolvePullRequestAutofill(
+  env: NodeJS.ProcessEnv = process.env,
+  options: TokenResolutionOptions = {},
+): Promise<boolean> {
+  const processValue = env[PULL_REQUEST_AUTOFILL_ENV_NAME];
+  if (processValue !== undefined) return parsePullRequestAutofillValue(processValue);
+
+  const dotEnvValues = await readDotEnvValues(options.cwd, options.signal, "pull request autofill configuration");
+  const dotEnvValue = dotEnvValues[PULL_REQUEST_AUTOFILL_ENV_NAME];
+  return dotEnvValue === undefined ? false : parsePullRequestAutofillValue(dotEnvValue);
 }
 
 export async function resolveGitHubToken(
@@ -281,7 +330,7 @@ export async function resolveGitHubToken(
   const processToken = resolveProcessToken(env);
   if (processToken) return processToken;
 
-  const dotEnvTokens = await readDotEnvTokens(options.cwd, options.signal);
+  const dotEnvTokens = await readDotEnvValues(options.cwd, options.signal);
   const githubToken = dotEnvTokens.GITHUB_TOKEN?.trim();
   if (githubToken) return { token: githubToken, source: "GITHUB_TOKEN (.env)" };