try:

proc = subprocess.run(

["git", *args],

cwd=path,

capture_output=True,

text=True,

errors="replace",

timeout=timeout,

check=False,

creationflags=NO_WINDOW,

)

except (OSError, subprocess.TimeoutExpired) as e:

raise GitError(str(e)) from e

if proc.returncode != 0:

raise GitError((proc.stderr or "").strip() or f"git {args[0]} failed")

"""Parse `git log --format=FORMAT` output into raw commit dicts."""

commits = []

for record in text.split(RECORD_SEP):

record = record.strip("\n")

if not record.strip():

continue

h, short, parents, author, date, subject, refs = record.split(FIELD_SEP)

commits.append({

"hash": h,

"short": short,

"parents": parents.split() if parents else [],

"author": author,

"date": date,

"subject": subject,

"refs": [r.strip() for r in refs.split(",") if r.strip()],

})

"""Assign `column`, `color`, `enter`, `exit`, and `through` to each commit in place.

lanes: dict[int, dict] = {} # column -> {"next": hash, "color": color}

next_color = 0

def new_color() -> str:

nonlocal next_color

c = PALETTE[next_color % len(PALETTE)]

next_color += 1

return c

def free_column() -> int:

return next((c for c in range(len(lanes) + 1) if c not in lanes), 0)

for commit in commits:

h = commit["hash"]

matches = sorted(col for col, lane in lanes.items() if lane["next"] == h)

if matches:

col, color = matches[0], lanes[matches[0]]["color"]

else:

col, color = free_column(), new_color()

enter, through = [], []

for other_col, lane in list(lanes.items()):

if other_col in matches:

enter.append({"from_col": other_col, "color": lane["color"]})

del lanes[other_col]

elif other_col != col:

through.append({"col": other_col, "color": lane["color"]})

exit_ = []

parents = commit["parents"]

if parents:

lanes[col] = {"next": parents[0], "color": color}

exit_.append({"to_col": col, "color": color})

for parent in parents[1:]:

free, pcolor = free_column(), new_color()

lanes[free] = {"next": parent, "color": pcolor}

exit_.append({"to_col": free, "color": pcolor})

else:

lanes.pop(col, None)

commit["column"] = col

commit["color"] = color

commit["enter"] = enter

commit["exit"] = exit_

"""Commit graph for the repo at `path`: local branches + HEAD."""

try:

branch = _run(path, ["rev-parse", "--abbrev-ref", "HEAD"], timeout=5).strip()

except GitError: # unborn HEAD: a fresh `git init` with no commits

return {"commits": [], "current_branch": "", "has_more": False}

raw = _run(path, ["log", "HEAD", "--branches", "--date-order", f"--format={FORMAT}",

"--date=format:%Y-%m-%dT%H:%M:%S", "-n", str(max_commits + 1)])

commits = parse_log(raw)

has_more = len(commits) > max_commits

commits = commits[:max_commits]

build_graph(commits)

"""`git checkout <ref>`. git itself refuses an unsafe checkout on a dirty tree."""

if ref.startswith("-"): # would be parsed as an option (e.g. --force)

return False, "invalid ref"

try:

out = _run(path, ["checkout", ref])

return True, out.strip()

except GitError as e:

"""Uncommitted changes at a glance: branch, ahead/behind and each changed file with its line counts."""

out = _run(path, ["status", "--porcelain=v1", "-z", "--branch", "--untracked-files=all"], timeout=10)

branch, ahead, behind, files = "", 0, 0, []

entries = out.split("\0")

i = 0

while i < len(entries):

e = entries[i]

i += 1

if not e:

continue

if e.startswith("## "):

head = e[3:]

branch = head.split("...")[0].replace("No commits yet on ", "")

ahead = int(m[1]) if (m := re.search(r"ahead (\d+)", head)) else 0

behind = int(m[1]) if (m := re.search(r"behind (\d+)", head)) else 0

continue

x, y, name = e[0], e[1], e[3:]

old = None

if "R" in (x, y) or "C" in (x, y):

old, i = entries[i], i + 1 # -z puts the rename source in the next entry

code = "?" if x == "?" else "U" if "U" in (x, y) or (x, y) in (("A", "A"), ("D", "D")) else (x if x != " " else y)

files.append({"path": name, "old_path": old, "status": STATUS_NAME.get(code, "modified"), "staged": x not in (" ", "?"),

"unstaged": y not in (" ",), "added": None, "deleted": None})

if files:

counts: dict[str, tuple[int | None, int | None]] = {}

try:

numstat = _run(path, ["diff", "HEAD", "--numstat", "-z", "--no-renames"], timeout=10)

except GitError: # no commits yet: compare the index with the empty tree

numstat = _run(path, ["diff", "--cached", "--numstat", "-z", "--no-renames"], timeout=10)

for rec in numstat.split("\0"):

parts = rec.split("\t")

if len(parts) == 3:

counts[parts[2]] = (None if parts[0] == "-" else int(parts[0]), None if parts[1] == "-" else int(parts[1]))

for f in files:

if f["path"] in counts:

f["added"], f["deleted"] = counts[f["path"]]

elif f["status"] == "untracked":

f["added"], f["deleted"] = _line_count(Path(path) / f["path"]), 0

try:

data = file.read_bytes()[:MAX_DIFF]

except OSError:

return None

"""One changed file's diff against HEAD (staged and unstaged together); an untracked file shows as all added.

entry = next((f for f in changes(path)["files"] if f["path"] == file), None)

if not entry:

return {"file": file, "diff": "", "binary": False, "truncated": False, "missing": True}

if entry["status"] == "untracked":

target = Path(path) / file

try:

data = target.read_bytes()

except OSError:

data = b""

if b"\0" in data[:8000]:

return {"file": file, "diff": "", "binary": True, "truncated": False}

text = data[:MAX_DIFF].decode("utf-8", "replace")

body = "".join(f"+{line}\n" for line in text.splitlines())

return {"file": file, "diff": f"--- /dev/null\n+++ b/{file}\n{body}", "binary": False, "truncated": len(data) > MAX_DIFF}

try:

out = _run(path, ["diff", "HEAD", "--no-color", "--no-ext-diff", "--", file], timeout=10)

except GitError:

out = _run(path, ["diff", "--cached", "--no-color", "--no-ext-diff", "--", file], timeout=10)