@senad-d/branchme 0.1.3 → 0.1.5

package/src/git.ts

@@ -1,6 +1,10 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
+  GIT_CONTEXT_CHANGE_LIMIT,
+  GIT_CONTEXT_RECENT_COMMIT_LIMIT,
+  GIT_CONTEXT_VALUE_LIMIT_CHARS,
   GIT_MUTATION_TIMEOUT_MS,
+  GIT_PULL_TIMEOUT_MS,
   GIT_PUSH_TIMEOUT_MS,
   GIT_STATUS_TIMEOUT_MS,
   MAX_SUMMARY_OUTPUT_CHARS,
@@ -13,7 +17,12 @@ import type {
   CreateBranchDetails,
   CurrentBranchInfo,
   GitExecResult,
+  GitFileChange,
+  GitFileChangeSummary,
+  PullBranchDetails,
   PushBranchDetails,
+  RecentCommit,
+  WorkingTreeDetails,
 } from "./types.ts";
 
 export interface GitCommandContext {
@@ -175,6 +184,12 @@ export async function getUpstreamBranch(
   return upstream || null;
 }
 
+interface ConfiguredUpstreamTarget {
+  upstream: string;
+  remote: string;
+  remoteRef: string;
+}
+
 interface PushTarget {
   upstream: string | null;
   mode: "push" | "publish";
@@ -184,21 +199,23 @@ interface PushTarget {
   args: string[];
 }
 
-function validateRemoteName(remote: string): void {
-  if (!remote) throw new Error("Unable to push current branch: upstream remote is missing.");
-  if (remote === ".") throw new Error("Unable to push current branch: upstream is a local branch, not a remote.");
-  if (remote.startsWith("-")) throw new Error("Unable to push current branch: upstream remote cannot start with '-'.");
+type UpstreamOperation = "pull" | "push";
+
+function validateRemoteName(remote: string, operation: UpstreamOperation): void {
+  if (!remote) throw new Error(`Unable to ${operation} current branch: upstream remote is missing.`);
+  if (remote === ".") throw new Error(`Unable to ${operation} current branch: upstream is a local branch, not a remote.`);
+  if (remote.startsWith("-")) throw new Error(`Unable to ${operation} current branch: upstream remote cannot start with '-'.`);
   if (remote.includes(":") || remote.includes("@")) {
-    throw new Error("Unable to push current branch: upstream remote name cannot be a URL or user-prefixed target.");
+    throw new Error(`Unable to ${operation} current branch: upstream remote name cannot be a URL or user-prefixed target.`);
   }
   if (/[\u0000-\u001f\u007f]/u.test(remote) || /\s/u.test(remote)) {
-    throw new Error("Unable to push current branch: upstream remote contains whitespace or control characters.");
+    throw new Error(`Unable to ${operation} current branch: upstream remote contains whitespace or control characters.`);
   }
 }
 
-function normalizeRemoteHeadRef(mergeRef: string): string {
+function normalizeRemoteHeadRef(mergeRef: string, operation: UpstreamOperation): string {
   if (!mergeRef.startsWith("refs/heads/")) {
-    throw new Error("Unable to push current branch: upstream merge ref is not a branch ref.");
+    throw new Error(`Unable to ${operation} current branch: upstream merge ref is not a branch ref.`);
   }
 
   const branchName = mergeRef.slice("refs/heads/".length);
@@ -224,15 +241,39 @@ async function getBranchConfigValue(
   return value || null;
 }
 
-async function resolvePushTarget(
+async function resolveConfiguredUpstreamTarget(
   pi: Pick<ExtensionAPI, "exec">,
   ctx: GitCommandContext,
   currentBranch: string,
+  operation: UpstreamOperation,
   signal?: AbortSignal,
-): Promise<PushTarget> {
+): Promise<ConfiguredUpstreamTarget | null> {
   validateBranchNameInput(currentBranch);
   const upstream = await getUpstreamBranch(pi, ctx, signal);
-  if (!upstream) {
+  if (!upstream) return null;
+
+  const remote = await getBranchConfigValue(pi, ctx, currentBranch, "remote", signal);
+  const mergeRef = await getBranchConfigValue(pi, ctx, currentBranch, "merge", signal);
+  if (!remote || !mergeRef) {
+    throw new Error(`Unable to ${operation} current branch: upstream exists but branch remote/merge configuration is incomplete.`);
+  }
+
+  validateRemoteName(remote, operation);
+  return {
+    upstream,
+    remote,
+    remoteRef: normalizeRemoteHeadRef(mergeRef, operation),
+  };
+}
+
+async function resolvePushTarget(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  currentBranch: string,
+  signal?: AbortSignal,
+): Promise<PushTarget> {
+  const upstreamTarget = await resolveConfiguredUpstreamTarget(pi, ctx, currentBranch, "push", signal);
+  if (!upstreamTarget) {
     const remoteRef = `refs/heads/${currentBranch}`;
     return {
       upstream: null,
@@ -244,22 +285,12 @@ async function resolvePushTarget(
     };
   }
 
-  const remote = await getBranchConfigValue(pi, ctx, currentBranch, "remote", signal);
-  const mergeRef = await getBranchConfigValue(pi, ctx, currentBranch, "merge", signal);
-  if (!remote || !mergeRef) {
-    throw new Error("Unable to push current branch: upstream exists but branch remote/merge configuration is incomplete.");
-  }
-
-  validateRemoteName(remote);
-  const remoteRef = normalizeRemoteHeadRef(mergeRef);
-  const refspec = `HEAD:${remoteRef}`;
+  const refspec = `HEAD:${upstreamTarget.remoteRef}`;
   return {
-    upstream,
+    ...upstreamTarget,
     mode: "push",
-    remote,
-    remoteRef,
     refspec,
-    args: ["push", remote, refspec],
+    args: ["push", upstreamTarget.remote, refspec],
   };
 }
 
@@ -277,6 +308,251 @@ export async function hasWorkingTreeChanges(
     .some((line) => line.length > 0 && !line.startsWith("## "));
 }
 
+export interface WorkingTreeStatus {
+  workingTree: WorkingTreeDetails;
+  unstagedChanges: GitFileChangeSummary;
+}
+
+const UNMERGED_GIT_STATUSES = new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+const GIT_STATUS_CODE_PATTERN = /^[ MADRCUT?!]{2}$/u;
+const GIT_LOG_FIELD_SEPARATOR = "\u001f";
+const NUL_SEPARATOR = "\u0000";
+const GIT_LOG_FORMAT = `%x00%H%x1f%h%x1f%ad%x1f%s`;
+
+function truncateGitContextValue(value: string): string {
+  if (value.length <= GIT_CONTEXT_VALUE_LIMIT_CHARS) return value;
+
+  let end = GIT_CONTEXT_VALUE_LIMIT_CHARS - 1;
+  const lastCodePoint = value.codePointAt(end - 1);
+  if (lastCodePoint !== undefined && lastCodePoint > 0xffff) end -= 1;
+  return `${value.slice(0, end)}…`;
+}
+
+function escapeGitContextControlCharacter(character: string): string {
+  const codePoint = character.codePointAt(0);
+  return codePoint === undefined ? "" : String.raw`\u${codePoint.toString(16).padStart(4, "0")}`;
+}
+
+function safeGitContextValue(value: string): string {
+  const redacted = redactSecrets(value);
+  const escaped = redacted.replace(/[\p{Cc}\p{Cf}\u2028\u2029]/gu, escapeGitContextControlCharacter);
+  return truncateGitContextValue(escaped);
+}
+
+function isRenameOrCopyStatus(status: string): boolean {
+  return status.startsWith("R") || status.startsWith("C") || status.endsWith("R") || status.endsWith("C");
+}
+
+function parsePorcelainRecord(record: string): { status: string; path: string } {
+  if (record.length < 4 || record[2] !== " ") {
+    throw new TypeError("Unable to parse working-tree state: malformed git status record.");
+  }
+
+  const status = record.slice(0, 2);
+  const path = record.slice(3);
+  if (!GIT_STATUS_CODE_PATTERN.test(status) || status === "  " || path.length === 0) {
+    throw new TypeError("Unable to parse working-tree state: malformed git status record.");
+  }
+  return { status, path };
+}
+
+function appendUnstagedChange(
+  entries: GitFileChange[],
+  change: GitFileChange,
+  omitted: number,
+): number {
+  if (entries.length < GIT_CONTEXT_CHANGE_LIMIT) {
+    entries.push(change);
+    return omitted;
+  }
+  return omitted + 1;
+}
+
+interface ParsedPorcelainChange {
+  status: string;
+  path: string;
+  originalPath?: string;
+  nextIndex: number;
+}
+
+interface WorkingTreeChangeCounts {
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  includeInUnstagedChanges: boolean;
+}
+
+function parsePorcelainChange(records: string[], index: number): ParsedPorcelainChange {
+  const parsed = parsePorcelainRecord(records[index]);
+  if (!isRenameOrCopyStatus(parsed.status)) return { ...parsed, nextIndex: index };
+
+  const originalPath = records[index + 1];
+  if (originalPath === undefined || originalPath.length === 0) {
+    throw new TypeError("Unable to parse working-tree state: rename or copy source path is missing.");
+  }
+  return { ...parsed, originalPath, nextIndex: index + 1 };
+}
+
+function workingTreeChangeCounts(status: string): WorkingTreeChangeCounts {
+  const isUntracked = status === "??";
+  const isUnmerged = UNMERGED_GIT_STATUSES.has(status);
+  const hasStagedChange = !isUntracked && !isUnmerged && !status.startsWith(" ");
+  const hasUnstagedChange = !isUntracked && (isUnmerged || !status.endsWith(" "));
+
+  return {
+    staged: Number(hasStagedChange),
+    unstaged: Number(hasUnstagedChange),
+    untracked: Number(isUntracked),
+    includeInUnstagedChanges: isUntracked || hasUnstagedChange,
+  };
+}
+
+function gitFileChange(parsed: ParsedPorcelainChange): GitFileChange {
+  return {
+    status: parsed.status,
+    path: safeGitContextValue(parsed.path),
+    ...(parsed.originalPath === undefined
+      ? {}
+      : { originalPath: safeGitContextValue(parsed.originalPath) }),
+  };
+}
+
+export function parseWorkingTreeStatus(output: string): WorkingTreeStatus {
+  const records = output.split(NUL_SEPARATOR);
+  const entries: GitFileChange[] = [];
+  let staged = 0;
+  let unstaged = 0;
+  let untracked = 0;
+  let omitted = 0;
+  let dirty = false;
+  let skipNextRecord = false;
+
+  for (const [index, record] of records.entries()) {
+    if (skipNextRecord) {
+      skipNextRecord = false;
+      continue;
+    }
+    if (record.length === 0) continue;
+
+    const parsed = parsePorcelainChange(records, index);
+    skipNextRecord = parsed.nextIndex > index;
+    if (parsed.status === "!!") continue;
+    dirty = true;
+
+    const counts = workingTreeChangeCounts(parsed.status);
+    staged += counts.staged;
+    unstaged += counts.unstaged;
+    untracked += counts.untracked;
+    if (!counts.includeInUnstagedChanges) continue;
+
+    omitted = appendUnstagedChange(entries, gitFileChange(parsed), omitted);
+  }
+
+  return {
+    workingTree: {
+      state: dirty ? "dirty" : "clean",
+      staged,
+      unstaged,
+      untracked,
+    },
+    unstagedChanges: { entries, omitted },
+  };
+}
+
+export async function getWorkingTreeStatus(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  signal?: AbortSignal,
+): Promise<WorkingTreeStatus> {
+  const repoRoot = await getGitRoot(pi, ctx, signal);
+  const args = ["status", "--porcelain=v1", "-z", "--untracked-files=normal"];
+  const result = await runGit(pi, { cwd: repoRoot }, args, {
+    signal,
+    timeout: GIT_STATUS_TIMEOUT_MS,
+  });
+  return parseWorkingTreeStatus(result.stdout);
+}
+
+function stripGitLogRecordTerminator(record: string): string {
+  if (record.endsWith("\r\n")) return record.slice(0, -2);
+  if (record.endsWith("\n")) return record.slice(0, -1);
+  return record;
+}
+
+function parseRecentCommitRecord(record: string): RecentCommit {
+  const firstSeparator = record.indexOf(GIT_LOG_FIELD_SEPARATOR);
+  const secondSeparator = record.indexOf(GIT_LOG_FIELD_SEPARATOR, firstSeparator + 1);
+  const thirdSeparator = record.indexOf(GIT_LOG_FIELD_SEPARATOR, secondSeparator + 1);
+  if (firstSeparator < 1 || secondSeparator <= firstSeparator + 1 || thirdSeparator <= secondSeparator + 1) {
+    throw new TypeError("Unable to parse recent commits: malformed git log output.");
+  }
+
+  const hash = record.slice(0, firstSeparator);
+  const shortHash = record.slice(firstSeparator + 1, secondSeparator);
+  const date = record.slice(secondSeparator + 1, thirdSeparator);
+  const subject = record.slice(thirdSeparator + 1);
+  if (
+    !/^[0-9a-f]{40,64}$/iu.test(hash) ||
+    !/^[0-9a-f]{4,64}$/iu.test(shortHash) ||
+    !hash.toLowerCase().startsWith(shortHash.toLowerCase()) ||
+    !/^\d{4}-\d{2}-\d{2}$/u.test(date)
+  ) {
+    throw new TypeError("Unable to parse recent commits: malformed git log output.");
+  }
+
+  return {
+    hash,
+    shortHash,
+    date,
+    subject: safeGitContextValue(subject),
+  };
+}
+
+export function parseRecentCommits(output: string): RecentCommit[] {
+  const records = output.split(NUL_SEPARATOR);
+  const commits: RecentCommit[] = [];
+  for (const rawRecord of records) {
+    if (rawRecord.length === 0) continue;
+    const record = stripGitLogRecordTerminator(rawRecord);
+    if (record.length === 0) continue;
+    commits.push(parseRecentCommitRecord(record));
+    if (commits.length === GIT_CONTEXT_RECENT_COMMIT_LIMIT) break;
+  }
+  return commits;
+}
+
+export async function getRecentCommits(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  signal?: AbortSignal,
+): Promise<RecentCommit[]> {
+  const repoRoot = await getGitRoot(pi, ctx, signal);
+  const rootCtx = { cwd: repoRoot };
+  const args = [
+    "log",
+    "-n",
+    String(GIT_CONTEXT_RECENT_COMMIT_LIMIT),
+    "--date=short",
+    `--format=${GIT_LOG_FORMAT}`,
+    "HEAD",
+  ];
+  const result = await runGit(pi, rootCtx, args, {
+    signal,
+    timeout: GIT_STATUS_TIMEOUT_MS,
+    allowFailure: true,
+  });
+  if (result.code === 0) return parseRecentCommits(result.stdout);
+  if (signal?.aborted) throw new Error(formatGitFailure(args, result));
+
+  const verifyHead = await runGit(pi, rootCtx, ["rev-parse", "--verify", "HEAD"], {
+    signal,
+    timeout: GIT_STATUS_TIMEOUT_MS,
+    allowFailure: true,
+  });
+  if (verifyHead.code !== 0) return [];
+  throw new Error(formatGitFailure(args, result));
+}
+
 export async function getAheadBehindCount(
   pi: Pick<ExtensionAPI, "exec">,
   ctx: GitCommandContext,
@@ -424,6 +700,41 @@ export async function changeExistingLocalBranch(
   });
 }
 
+export async function pullCurrentBranch(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  signal?: AbortSignal,
+): Promise<PullBranchDetails> {
+  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 pulling the current branch.");
+    }
+
+    const target = await resolveConfiguredUpstreamTarget(pi, rootCtx, currentBranch, "pull", signal);
+    if (!target) {
+      throw new Error(`Unable to pull current branch '${safeDetail(currentBranch)}': no upstream is configured.`);
+    }
+
+    const result = await runGit(pi, rootCtx, ["pull", "--ff-only", "--no-rebase", "--no-autostash", target.remote, target.remoteRef], {
+      signal,
+      timeout: GIT_PULL_TIMEOUT_MS,
+    });
+
+    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,