@oh-my-pi/pi-git-tool 3.20.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## [Unreleased]
+
+## [3.20.0] - 2026-01-06
+
+### Breaking Changes
+
+### Added
+
+- Added structured git tool with safety guards, caching, and GitHub operations
+
+### Changed
+
+### Fixed
+
+### Removed

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@oh-my-pi/pi-git-tool",
+	"version": "3.20.0",
+	"description": "Structured Git tool with safety guards and typed output",
+	"type": "module",
+	"main": "./src/index.ts",
+	"types": "./src/index.ts",
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts"
+		}
+	},
+	"files": [
+		"src",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"check": "tsgo --noEmit",
+		"build": "tsgo -p tsconfig.build.json",
+		"test": "vitest --run"
+	},
+	"devDependencies": {
+		"@types/node": "^24.3.0",
+		"vitest": "^3.2.4"
+	},
+	"keywords": [
+		"git",
+		"tool",
+		"agent"
+	],
+	"author": "Can Bölük",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/can1357/oh-my-pi.git",
+		"directory": "packages/git-tool"
+	},
+	"engines": {
+		"bun": ">=1.0.0"
+	}
+}

package/src/cache/git-cache.ts

@@ -0,0 +1,35 @@
+import type { BranchListResult, Commit, StatusResult } from "../types";
+
+export interface CacheEntry<T> {
+	value: T;
+	timestamp: number;
+	ttl: number;
+	cwd: string;
+}
+
+export interface GitCache {
+	branch: CacheEntry<BranchListResult> | null;
+	status: CacheEntry<StatusResult> | null;
+	remotes: CacheEntry<Array<{ name: string; url: string }>> | null;
+	commits: Map<string, CacheEntry<Commit>>;
+}
+
+export const DEFAULT_TTL = {
+	branch: 30_000,
+	status: 5_000,
+	remotes: 60_000,
+	commits: 300_000,
+};
+
+export function createCache(): GitCache {
+	return {
+		branch: null,
+		status: null,
+		remotes: null,
+		commits: new Map(),
+	};
+}
+
+export function isExpired(entry: CacheEntry<unknown>): boolean {
+	return Date.now() - entry.timestamp > entry.ttl;
+}

package/src/errors.ts

@@ -0,0 +1,84 @@
+export enum GitErrorCode {
+	NOT_A_REPO = "NOT_A_REPO",
+	CONFLICT = "CONFLICT",
+	UNCOMMITTED_CHANGES = "UNCOMMITTED_CHANGES",
+	BRANCH_NOT_FOUND = "BRANCH_NOT_FOUND",
+	REF_NOT_FOUND = "REF_NOT_FOUND",
+	REMOTE_REJECTED = "REMOTE_REJECTED",
+	AUTH_FAILED = "AUTH_FAILED",
+	MERGE_CONFLICT = "MERGE_CONFLICT",
+	REBASE_CONFLICT = "REBASE_CONFLICT",
+	NOTHING_TO_COMMIT = "NOTHING_TO_COMMIT",
+	DETACHED_HEAD = "DETACHED_HEAD",
+	HOOK_FAILED = "HOOK_FAILED",
+	GH_NOT_INSTALLED = "GH_NOT_INSTALLED",
+	GH_AUTH_REQUIRED = "GH_AUTH_REQUIRED",
+	UNKNOWN = "UNKNOWN",
+}
+
+export class GitError extends Error {
+	code: GitErrorCode;
+	details?: Record<string, unknown>;
+
+	constructor(message: string, code: GitErrorCode, details?: Record<string, unknown>) {
+		super(message);
+		this.name = "GitError";
+		this.code = code;
+		this.details = details;
+	}
+}
+
+export function detectGitError(stderr: string, exitCode: number): GitError | null {
+	if (exitCode === 0) return null;
+
+	const normalized = stderr.toLowerCase();
+	if (normalized.includes("not a git repository")) {
+		return new GitError("Not a git repository", GitErrorCode.NOT_A_REPO);
+	}
+	if (normalized.includes("authentication failed") || normalized.includes("fatal: authentication")) {
+		return new GitError("Authentication failed", GitErrorCode.AUTH_FAILED);
+	}
+	if (normalized.includes("permission denied") || normalized.includes("access denied")) {
+		return new GitError("Authentication failed", GitErrorCode.AUTH_FAILED);
+	}
+	if (normalized.includes("nothing to commit")) {
+		return new GitError("Nothing to commit", GitErrorCode.NOTHING_TO_COMMIT);
+	}
+	if (normalized.includes("detached head")) {
+		return new GitError("Detached HEAD", GitErrorCode.DETACHED_HEAD);
+	}
+	if (normalized.includes("merge conflict") || normalized.includes("conflict")) {
+		return new GitError("Merge conflict", GitErrorCode.MERGE_CONFLICT);
+	}
+	if (normalized.includes("rebase")) {
+		return new GitError("Rebase conflict", GitErrorCode.REBASE_CONFLICT);
+	}
+	if (normalized.includes("unknown revision") || normalized.includes("bad revision")) {
+		return new GitError("Ref not found", GitErrorCode.REF_NOT_FOUND);
+	}
+	if (normalized.includes("pathspec") && normalized.includes("did not match")) {
+		return new GitError("Ref not found", GitErrorCode.REF_NOT_FOUND);
+	}
+	if (normalized.includes("hook") && normalized.includes("failed")) {
+		return new GitError("Hook failed", GitErrorCode.HOOK_FAILED);
+	}
+	if (normalized.includes("remote rejected") || normalized.includes("rejected")) {
+		return new GitError("Remote rejected", GitErrorCode.REMOTE_REJECTED);
+	}
+
+	return new GitError(stderr.trim() || "Unknown git error", GitErrorCode.UNKNOWN);
+}
+
+export function detectGhError(stderr: string, exitCode: number): GitError | null {
+	if (exitCode === 0) return null;
+
+	const normalized = stderr.toLowerCase();
+	if (normalized.includes("not logged") || normalized.includes("authentication required")) {
+		return new GitError("GitHub CLI authentication required", GitErrorCode.GH_AUTH_REQUIRED);
+	}
+	if (normalized.includes("gh: not found") || normalized.includes("gh: command not found")) {
+		return new GitError("GitHub CLI is not installed", GitErrorCode.GH_NOT_INSTALLED);
+	}
+
+	return new GitError(stderr.trim() || "GitHub CLI error", GitErrorCode.UNKNOWN);
+}

package/src/git-tool.ts

@@ -0,0 +1,169 @@
+import { createCache, DEFAULT_TTL, isExpired } from "./cache/git-cache";
+import { add } from "./operations/add";
+import { blame } from "./operations/blame";
+import { branch } from "./operations/branch";
+import { checkout } from "./operations/checkout";
+import { cherryPick } from "./operations/cherry-pick";
+import { commit } from "./operations/commit";
+import { diff } from "./operations/diff";
+import { fetch } from "./operations/fetch";
+import { ci } from "./operations/github/ci";
+import { issue } from "./operations/github/issue";
+import { pr } from "./operations/github/pr";
+import { release } from "./operations/github/release";
+import { log } from "./operations/log";
+import { merge } from "./operations/merge";
+import { pull } from "./operations/pull";
+import { push } from "./operations/push";
+import { rebase } from "./operations/rebase";
+import { restore } from "./operations/restore";
+import { show } from "./operations/show";
+import { stash } from "./operations/stash";
+import { status } from "./operations/status";
+import { tag } from "./operations/tag";
+import { renderBranchList, renderStatus } from "./render";
+import { checkSafety } from "./safety/guards";
+import type { BranchListResult, GitParams, Operation, StatusResult, ToolResponse, ToolResult } from "./types";
+import { isTruthy } from "./utils";
+
+const cache = createCache();
+
+type OperationHandler = (params: GitParams, cwd?: string) => Promise<ToolResponse<unknown>>;
+
+const operations: Record<Operation, OperationHandler> = {
+	status: status as OperationHandler,
+	diff: diff as OperationHandler,
+	log: log as OperationHandler,
+	show: show as OperationHandler,
+	blame: blame as OperationHandler,
+	branch: branch as OperationHandler,
+	add: add as OperationHandler,
+	restore: restore as OperationHandler,
+	commit: commit as OperationHandler,
+	checkout: checkout as OperationHandler,
+	merge: merge as OperationHandler,
+	rebase: rebase as OperationHandler,
+	stash: stash as OperationHandler,
+	"cherry-pick": cherryPick as OperationHandler,
+	fetch: fetch as OperationHandler,
+	pull: pull as OperationHandler,
+	push: push as OperationHandler,
+	tag: tag as OperationHandler,
+	pr: pr as OperationHandler,
+	issue: issue as OperationHandler,
+	ci: ci as OperationHandler,
+	release: release as OperationHandler,
+};
+
+const READ_OPERATIONS: Operation[] = ["status", "diff", "log", "show", "blame", "branch"];
+const WRITE_OPERATIONS: Operation[] = [
+	"add",
+	"restore",
+	"commit",
+	"checkout",
+	"merge",
+	"rebase",
+	"stash",
+	"cherry-pick",
+	"pull",
+	"fetch",
+];
+
+function invalidateOnWrite(operation: Operation): void {
+	if (WRITE_OPERATIONS.includes(operation)) {
+		cache.status = null;
+		if (["checkout", "merge", "rebase"].includes(operation)) {
+			cache.branch = null;
+		}
+	}
+}
+
+function cacheStatus(result: ToolResult<StatusResult>, cwd: string): void {
+	cache.status = { value: result.data, timestamp: Date.now(), ttl: DEFAULT_TTL.status, cwd };
+}
+
+function cacheBranch(result: ToolResult<BranchListResult>, cwd: string): void {
+	cache.branch = { value: result.data, timestamp: Date.now(), ttl: DEFAULT_TTL.branch, cwd };
+}
+
+function getCachedStatus(cwd: string): ToolResult<StatusResult> | null {
+	if (!cache.status) return null;
+	if (isExpired(cache.status)) {
+		cache.status = null;
+		return null;
+	}
+	if (cache.status.cwd !== cwd) return null;
+	return {
+		data: cache.status.value,
+		_rendered: renderStatus(cache.status.value),
+	};
+}
+
+function getCachedBranch(cwd: string): ToolResult<BranchListResult> | null {
+	if (!cache.branch) return null;
+	if (isExpired(cache.branch)) {
+		cache.branch = null;
+		return null;
+	}
+	if (cache.branch.cwd !== cwd) return null;
+	return {
+		data: cache.branch.value,
+		_rendered: renderBranchList(cache.branch.value),
+	};
+}
+
+export async function gitTool(params: GitParams, cwd?: string): Promise<ToolResponse<unknown>> {
+	const resolvedCwd = cwd ?? process.cwd();
+	const operation = params.operation as Operation;
+	const handler = operations[operation];
+	if (!handler) {
+		return { error: `Unknown operation: ${operation}` };
+	}
+
+	const paramRecord = params as unknown as Record<string, unknown>;
+	const safety = await checkSafety(operation, paramRecord, resolvedCwd);
+	if (safety.blocked) {
+		const overrideValue = safety.override ? paramRecord[safety.override] : undefined;
+		if (!safety.override || !isTruthy(String(overrideValue ?? ""))) {
+			return { error: safety.message ?? "Operation blocked", suggestion: safety.suggestion, code: "SAFETY_BLOCK" };
+		}
+	}
+	if (safety.confirm) {
+		const overrideValue = safety.override ? paramRecord[safety.override] : undefined;
+		if (!safety.override || !isTruthy(String(overrideValue ?? ""))) {
+			return {
+				confirm: safety.message ?? "Confirmation required",
+				override: safety.override ?? "confirm",
+				_rendered: safety.message,
+			};
+		}
+	}
+
+	if (READ_OPERATIONS.includes(operation)) {
+		if (operation === "status") {
+			const cached = getCachedStatus(resolvedCwd);
+			const statusParams = params as { only?: string; ignored?: boolean };
+			if (cached && !statusParams.only && !statusParams.ignored) return cached;
+		}
+		if (operation === "branch") {
+			const cached = getCachedBranch(resolvedCwd);
+			const branchParams = params as { action?: string; remotes?: boolean };
+			if (cached && (!branchParams.action || branchParams.action === "list") && !branchParams.remotes) return cached;
+		}
+	}
+
+	const result = await handler(params, resolvedCwd);
+
+	invalidateOnWrite(operation);
+	if ("data" in result && READ_OPERATIONS.includes(operation)) {
+		if (operation === "status") cacheStatus(result as ToolResult<StatusResult>, resolvedCwd);
+		if (operation === "branch") cacheBranch(result as ToolResult<BranchListResult>, resolvedCwd);
+	}
+
+	if ("data" in result && safety.warnings.length > 0) {
+		const suffix = `\n\nWarnings:\n${safety.warnings.map((warn) => `- ${warn}`).join("\n")}`;
+		result._rendered = `${result._rendered ?? ""}${suffix}`;
+	}
+
+	return result;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./errors";
+export { gitTool } from "./git-tool";
+export * from "./types";

package/src/operations/add.ts

@@ -0,0 +1,42 @@
+import { renderAdd } from "../render";
+import type { AddParams, AddResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+function parseDryRun(output: string): string[] {
+	const files: string[] = [];
+	for (const line of output.split("\n")) {
+		const match = line.match(/add ['"]?(.*?)['"]?$/i);
+		if (match) {
+			files.push(match[1]);
+		}
+	}
+	return files;
+}
+
+export async function add(params: AddParams, cwd?: string): Promise<ToolResult<AddResult> | ToolError> {
+	const args = ["add"];
+	if (params.dry_run) args.push("--dry-run");
+	if (params.update) args.push("-u");
+	if (params.all) args.push("-A");
+	if (params.paths && params.paths.length > 0) {
+		args.push("--", ...params.paths);
+	}
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	let staged: string[] = [];
+	if (params.dry_run) {
+		staged = parseDryRun(result.stdout);
+	} else {
+		const stagedResult = await git(["diff", "--name-only", "--cached"], { cwd });
+		if (!stagedResult.error) {
+			staged = stagedResult.stdout.split("\n").filter(Boolean);
+		}
+	}
+
+	const data: AddResult = { staged };
+	return { data, _rendered: renderAdd(data) };
+}

package/src/operations/blame.ts

@@ -0,0 +1,23 @@
+import { parseBlame } from "../parsers/blame-parser";
+import { renderBlame } from "../render";
+import type { BlameParams, BlameResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+export async function blame(params: BlameParams, cwd?: string): Promise<ToolResult<BlameResult> | ToolError> {
+	const args = ["blame", "--porcelain"];
+	if (params.root) args.push("--root");
+	if (params.ignore_whitespace) args.push("-w");
+	if (params.lines) {
+		args.push("-L", `${params.lines.start},${params.lines.end}`);
+	}
+	args.push(params.path);
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const parsed = parseBlame(result.stdout);
+	const data: BlameResult = { lines: parsed };
+	return { data, _rendered: renderBlame(data) };
+}

package/src/operations/branch.ts

@@ -0,0 +1,115 @@
+import { renderBranchList } from "../render";
+import type { BranchInfo, BranchListResult, BranchParams, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+function parseTrack(track: string): { ahead?: number; behind?: number; gone?: boolean } {
+	const result: { ahead?: number; behind?: number; gone?: boolean } = {};
+	if (!track) return result;
+	if (track.includes("gone")) result.gone = true;
+	const aheadMatch = track.match(/ahead (\d+)/);
+	const behindMatch = track.match(/behind (\d+)/);
+	if (aheadMatch) result.ahead = Number.parseInt(aheadMatch[1], 10);
+	if (behindMatch) result.behind = Number.parseInt(behindMatch[1], 10);
+	return result;
+}
+
+function parseBranchLines(output: string): BranchInfo[] {
+	const branches: BranchInfo[] = [];
+	for (const line of output.split("\n")) {
+		if (!line) continue;
+		const parts = line.split("\x00");
+		if (parts.length < 2) continue;
+		const name = parts[0];
+		const sha = parts[1];
+		const upstream = parts[2] || undefined;
+		const track = parts[3] || "";
+		const { ahead, behind, gone } = parseTrack(track);
+		branches.push({ name, sha, upstream, ahead, behind, gone });
+	}
+	return branches;
+}
+
+export async function branch(params: BranchParams, cwd?: string): Promise<ToolResult<BranchListResult> | ToolError> {
+	const action = params.action ?? "list";
+
+	if (action === "current") {
+		const currentResult = await git(["branch", "--show-current"], { cwd });
+		if (currentResult.error) {
+			return { error: currentResult.error.message, code: currentResult.error.code };
+		}
+		const data: BranchListResult = { current: currentResult.stdout.trim(), local: [] };
+		return { data, _rendered: renderBranchList(data) };
+	}
+
+	if (action === "create") {
+		if (!params.name) {
+			return { error: "Branch name required" };
+		}
+		const args = ["branch", params.name];
+		if (params.startPoint) args.push(params.startPoint);
+		const result = await git(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+	}
+
+	if (action === "delete") {
+		if (!params.name) {
+			return { error: "Branch name required" };
+		}
+		const args = ["branch", params.force ? "-D" : "-d", params.name];
+		const result = await git(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+	}
+
+	if (action === "rename") {
+		if (!params.name || !params.newName) {
+			return { error: "Branch name and newName required" };
+		}
+		const result = await git(["branch", "-m", params.name, params.newName], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+	}
+
+	const currentResult = await git(["branch", "--show-current"], { cwd });
+	if (currentResult.error) {
+		return { error: currentResult.error.message, code: currentResult.error.code };
+	}
+	const current = currentResult.stdout.trim();
+
+	const listResult = await git(
+		[
+			"branch",
+			"-vv",
+			"--format=%(refname:short)%x00%(objectname:short)%x00%(upstream:short)%x00%(upstream:track,nobracket)",
+		],
+		{ cwd },
+	);
+	if (listResult.error) {
+		return { error: listResult.error.message, code: listResult.error.code };
+	}
+	const local = parseBranchLines(listResult.stdout);
+
+	let remote: BranchInfo[] | undefined;
+	if (params.remotes) {
+		const remoteResult = await git(
+			[
+				"branch",
+				"-r",
+				"-vv",
+				"--format=%(refname:short)%x00%(objectname:short)%x00%(upstream:short)%x00%(upstream:track,nobracket)",
+			],
+			{ cwd },
+		);
+		if (remoteResult.error) {
+			return { error: remoteResult.error.message, code: remoteResult.error.code };
+		}
+		remote = parseBranchLines(remoteResult.stdout);
+	}
+
+	const data: BranchListResult = { current, local, ...(remote ? { remote } : {}) };
+	return { data, _rendered: renderBranchList(data) };
+}

package/src/operations/checkout.ts

@@ -0,0 +1,37 @@
+import type { CheckoutParams, CheckoutResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+export async function checkout(params: CheckoutParams, cwd?: string): Promise<ToolResult<CheckoutResult> | ToolError> {
+	const currentResult = await git(["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+	const previous = currentResult.error ? undefined : currentResult.stdout.trim();
+
+	if (params.paths && params.paths.length > 0) {
+		const args = ["checkout"];
+		if (params.ref) args.push(params.ref);
+		if (params.force) args.push("--force");
+		args.push("--", ...params.paths);
+		const result = await git(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: CheckoutResult = { previous, restoredFiles: params.paths };
+		return { data, _rendered: `Restored ${params.paths.length} files` };
+	}
+
+	if (!params.ref) {
+		return { error: "Ref is required for checkout" };
+	}
+
+	const args = ["checkout"];
+	if (params.create) args.push("-b");
+	if (params.force) args.push("--force");
+	args.push(params.ref);
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const data: CheckoutResult = { branch: params.ref, previous };
+	return { data, _rendered: `Checked out ${params.ref}` };
+}

package/src/operations/cherry-pick.ts

@@ -0,0 +1,39 @@
+import { GitErrorCode } from "../errors";
+import { renderCherryPick } from "../render";
+import type { CherryPickParams, CherryPickResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+async function getConflicts(cwd?: string): Promise<string[]> {
+	const result = await git(["diff", "--name-only", "--diff-filter=U"], { cwd });
+	if (result.error) return [];
+	return result.stdout.split("\n").filter(Boolean);
+}
+
+export async function cherryPick(
+	params: CherryPickParams,
+	cwd?: string,
+): Promise<ToolResult<CherryPickResult> | ToolError> {
+	const args = ["cherry-pick"];
+	if (params.abort) args.push("--abort");
+	if (params.continue) args.push("--continue");
+	if (params.no_commit) args.push("--no-commit");
+	if (!params.abort && !params.continue) {
+		if (!params.commits || params.commits.length === 0) {
+			return { error: "Commits are required for cherry-pick" };
+		}
+		args.push(...params.commits);
+	}
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		if (result.error.code === GitErrorCode.MERGE_CONFLICT) {
+			const conflicts = await getConflicts(cwd);
+			const data: CherryPickResult = { status: "conflict", conflicts };
+			return { data, _rendered: renderCherryPick(data) };
+		}
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const data: CherryPickResult = { status: "success", appliedCommits: params.commits };
+	return { data, _rendered: renderCherryPick(data) };
+}

package/src/operations/commit.ts

@@ -0,0 +1,52 @@
+import { renderCommit } from "../render";
+import { markCommitCreated } from "../safety/guards";
+import type { CommitParams, CommitResult, ToolError, ToolResult } from "../types";
+import { git, parseShortstat } from "../utils";
+
+export async function commit(params: CommitParams, cwd?: string): Promise<ToolResult<CommitResult> | ToolError> {
+	if (!params.message || params.message.trim().length === 0) {
+		return { error: "Commit message is required" };
+	}
+	const args = ["commit", "-m", params.message];
+	if (params.all) args.push("--all");
+	if (params.allow_empty) args.push("--allow-empty");
+	if (params.sign) args.push("-S");
+	if (params.no_verify) args.push("--no-verify");
+	if (params.amend) args.push("--amend");
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const shaResult = await git(["rev-parse", "HEAD"], { cwd });
+	if (shaResult.error) {
+		return { error: shaResult.error.message, code: shaResult.error.code };
+	}
+	const sha = shaResult.stdout.trim();
+	markCommitCreated(sha);
+
+	const subjectResult = await git(["show", "-s", "--format=%s", "HEAD"], { cwd });
+	if (subjectResult.error) {
+		return { error: subjectResult.error.message, code: subjectResult.error.code };
+	}
+	const subject = subjectResult.stdout.trim();
+
+	const statResult = await git(["show", "-s", "--shortstat", "HEAD"], { cwd });
+	let stats = { additions: 0, deletions: 0, files: 0 };
+	if (!statResult.error) {
+		const line = statResult.stdout.split("\n").find((statLine) => statLine.includes("files changed"));
+		const parsed = line ? parseShortstat(line) : null;
+		if (parsed) {
+			stats = { files: parsed.files, additions: parsed.additions, deletions: parsed.deletions };
+		}
+	}
+
+	const data: CommitResult = {
+		sha,
+		shortSha: sha.slice(0, 7),
+		subject,
+		stats,
+	};
+	return { data, _rendered: renderCommit(data) };
+}