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

package/src/operations/github/pr.ts

@@ -0,0 +1,247 @@
+import type {
+	PRActionResult,
+	PRCreateResult,
+	PRInfo,
+	PRListResult,
+	PRParams,
+	PRResult,
+	ToolError,
+	ToolResult,
+} from "../../types";
+import { gh } from "../../utils";
+
+function parseChecks(raw: unknown): { passing: number; failing: number; pending: number } | undefined {
+	if (!raw) return undefined;
+	if (Array.isArray(raw)) {
+		let passing = 0;
+		let failing = 0;
+		let pending = 0;
+		for (const check of raw) {
+			const status =
+				(check as { state?: string; conclusion?: string }).conclusion ?? (check as { state?: string }).state ?? "";
+			switch (status) {
+				case "SUCCESS":
+				case "success":
+					passing += 1;
+					break;
+				case "FAILURE":
+				case "failure":
+				case "ERROR":
+				case "error":
+					failing += 1;
+					break;
+				default:
+					pending += 1;
+			}
+		}
+		return { passing, failing, pending };
+	}
+	return undefined;
+}
+
+type GhPr = {
+	number: number;
+	title: string;
+	state: string;
+	author?: { login?: string } | string;
+	headRefName?: string;
+	baseRefName?: string;
+	branch?: string;
+	base?: string;
+	url: string;
+	createdAt: string;
+	updatedAt: string;
+	additions?: number;
+	deletions?: number;
+	commits?: number;
+	reviewDecision?: string | null;
+	checks?: unknown;
+	statusCheckRollup?: unknown;
+};
+
+function mapPrInfo(raw: GhPr): PRInfo {
+	const author = typeof raw.author === "string" ? raw.author : (raw.author?.login ?? "");
+	return {
+		number: raw.number,
+		title: raw.title,
+		state: raw.state,
+		author,
+		branch: raw.headRefName ?? raw.branch ?? "",
+		base: raw.baseRefName ?? raw.base ?? "",
+		url: raw.url,
+		createdAt: raw.createdAt,
+		updatedAt: raw.updatedAt,
+		additions: raw.additions ?? 0,
+		deletions: raw.deletions ?? 0,
+		commits: raw.commits ?? 0,
+		reviewDecision: raw.reviewDecision ?? undefined,
+		checks: parseChecks(raw.checks ?? raw.statusCheckRollup),
+	};
+}
+
+export async function pr(params: PRParams, cwd?: string): Promise<ToolResult<PRResult> | ToolError> {
+	if (params.action === "list") {
+		const args = [
+			"pr",
+			"list",
+			"--json",
+			"number,title,state,author,headRefName,baseRefName,url,createdAt,updatedAt,additions,deletions,commits,reviewDecision,checks",
+		];
+		if (params.limit) args.push("--limit", String(params.limit));
+		if (params.state) args.push("--state", params.state);
+		if (params.author) args.push("--author", params.author);
+		const result = await gh(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const raw = JSON.parse(result.stdout) as GhPr[];
+		const prs = raw.map((item) => mapPrInfo(item));
+		const data: PRListResult = { prs };
+		return { data, _rendered: `PRs: ${prs.length}` };
+	}
+
+	if (params.action === "view") {
+		if (!params.number) {
+			return { error: "PR number required" };
+		}
+		const result = await gh(
+			[
+				"pr",
+				"view",
+				String(params.number),
+				"--json",
+				"number,title,state,author,headRefName,baseRefName,url,createdAt,updatedAt,additions,deletions,commits,reviewDecision,checks",
+			],
+			{ cwd },
+		);
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const raw = JSON.parse(result.stdout) as GhPr;
+		const prInfo = mapPrInfo(raw);
+		return { data: { pr: prInfo }, _rendered: `PR #${prInfo.number}: ${prInfo.title}` };
+	}
+
+	if (params.action === "create") {
+		const args = ["pr", "create"];
+		if (params.title) args.push("--title", params.title);
+		if (params.body) args.push("--body", params.body);
+		if (params.base) args.push("--base", params.base);
+		if (params.head) args.push("--head", params.head);
+		if (params.draft) args.push("--draft");
+		const result = await gh(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+
+		let number = 0;
+		let url = "";
+		const viewArgs = ["pr", "view", "--json", "number,url"];
+		if (params.head) viewArgs.push("--head", params.head);
+		const viewResult = await gh(viewArgs, { cwd });
+		if (!viewResult.error && viewResult.stdout.trim().length > 0) {
+			const raw = JSON.parse(viewResult.stdout) as { number: number; url: string };
+			number = raw.number;
+			url = raw.url;
+		} else {
+			const match = result.stdout.match(/https?:\/\/\S+/);
+			if (match) {
+				url = match[0];
+				const numMatch = url.match(/pull\/(\d+)/);
+				if (numMatch) number = Number.parseInt(numMatch[1], 10);
+			}
+		}
+
+		const data: PRCreateResult = { number, url };
+		return { data, _rendered: url ? `Created PR ${url}` : "Created PR" };
+	}
+
+	if (params.action === "diff") {
+		if (!params.number) {
+			return { error: "PR number required" };
+		}
+		const result = await gh(["pr", "diff", String(params.number)], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: PRActionResult = { status: "success", diff: result.stdout };
+		return { data, _rendered: "PR diff" };
+	}
+
+	if (params.action === "checkout") {
+		if (!params.number) {
+			return { error: "PR number required" };
+		}
+		const result = await gh(["pr", "checkout", String(params.number)], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: PRActionResult = { status: "success" };
+		return { data, _rendered: `Checked out PR #${params.number}` };
+	}
+
+	if (params.action === "merge") {
+		if (!params.number) {
+			return { error: "PR number required" };
+		}
+		const args = ["pr", "merge", String(params.number)];
+		if (params.merge_method === "merge") args.push("--merge");
+		if (params.merge_method === "squash") args.push("--squash");
+		if (params.merge_method === "rebase") args.push("--rebase");
+		const result = await gh(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: PRActionResult = { status: "success" };
+		return { data, _rendered: `Merged PR #${params.number}` };
+	}
+
+	if (params.action === "close") {
+		if (!params.number) {
+			return { error: "PR number required" };
+		}
+		const result = await gh(["pr", "close", String(params.number)], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: PRActionResult = { status: "success" };
+		return { data, _rendered: `Closed PR #${params.number}` };
+	}
+
+	if (params.action === "ready") {
+		if (!params.number) {
+			return { error: "PR number required" };
+		}
+		const result = await gh(["pr", "ready", String(params.number)], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: PRActionResult = { status: "success" };
+		return { data, _rendered: `Marked PR #${params.number} ready` };
+	}
+
+	if (params.action === "review") {
+		if (!params.number) {
+			return { error: "PR number required" };
+		}
+		if (!params.review_action) {
+			return { error: "review_action required" };
+		}
+		if (params.review_action === "comment" && !params.review_body) {
+			return { error: "review_body required for comment review" };
+		}
+		const args = ["pr", "review", String(params.number)];
+		if (params.review_action === "approve") args.push("--approve");
+		if (params.review_action === "request-changes") args.push("--request-changes");
+		if (params.review_action === "comment") args.push("--comment");
+		if (params.review_body) args.push("--body", params.review_body);
+		const result = await gh(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: PRActionResult = { status: "success" };
+		return { data, _rendered: `Reviewed PR #${params.number}` };
+	}
+
+	return { error: `Unknown PR action: ${params.action}` };
+}

package/src/operations/github/release.ts

@@ -0,0 +1,109 @@
+import type { ReleaseInfo, ReleaseListResult, ReleaseParams, ReleaseResult, ToolError, ToolResult } from "../../types";
+import { gh } from "../../utils";
+
+type GhRelease = {
+	tagName?: string;
+	tag?: string;
+	name?: string;
+	body?: string;
+	isDraft?: boolean;
+	draft?: boolean;
+	isPrerelease?: boolean;
+	prerelease?: boolean;
+	createdAt: string;
+	publishedAt?: string;
+	url: string;
+	assets?: Array<{ name: string; size: number; downloadCount?: number; download_count?: number }>;
+};
+
+function mapReleaseInfo(raw: GhRelease): ReleaseInfo {
+	return {
+		tag: raw.tagName ?? raw.tag ?? "",
+		name: raw.name ?? "",
+		body: raw.body ?? "",
+		draft: raw.isDraft ?? raw.draft ?? false,
+		prerelease: raw.isPrerelease ?? raw.prerelease ?? false,
+		createdAt: raw.createdAt,
+		publishedAt: raw.publishedAt ?? "",
+		url: raw.url,
+		assets: (raw.assets ?? []).map((asset) => ({
+			name: asset.name,
+			size: asset.size,
+			downloadCount: asset.downloadCount ?? asset.download_count ?? 0,
+		})),
+	};
+}
+
+export async function release(params: ReleaseParams, cwd?: string): Promise<ToolResult<ReleaseResult> | ToolError> {
+	if (params.action === "list") {
+		const args = ["release", "list", "--json", "name,tagName,createdAt,publishedAt,isDraft,isPrerelease,url,assets"];
+		if (params.limit) args.push("--limit", String(params.limit));
+		const result = await gh(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const raw = JSON.parse(result.stdout) as GhRelease[];
+		const releases = raw.map((item) => mapReleaseInfo(item));
+		const data: ReleaseListResult = { releases };
+		return { data, _rendered: `Releases: ${releases.length}` };
+	}
+
+	if (params.action === "view") {
+		if (!params.tag) return { error: "tag required" };
+		const result = await gh(
+			[
+				"release",
+				"view",
+				params.tag,
+				"--json",
+				"name,tagName,body,createdAt,publishedAt,isDraft,isPrerelease,url,assets",
+			],
+			{ cwd },
+		);
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const info = mapReleaseInfo(JSON.parse(result.stdout) as GhRelease);
+		return { data: info, _rendered: `Release ${info.tag}` };
+	}
+
+	if (params.action === "create") {
+		if (!params.tag) return { error: "tag required" };
+		const args = ["release", "create", params.tag];
+		if (params.title) args.push("--title", params.title);
+		if (params.notes) args.push("--notes", params.notes);
+		if (params.generate_notes) args.push("--generate-notes");
+		if (params.draft) args.push("--draft");
+		if (params.prerelease) args.push("--prerelease");
+		if (params.target) args.push("--target", params.target);
+		const result = await gh(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const urlMatch = result.stdout.match(/https?:\/\/\S+/);
+		const url = urlMatch ? urlMatch[0] : undefined;
+		return { data: { status: "success", url }, _rendered: url ? `Created release ${url}` : "Created release" };
+	}
+
+	if (params.action === "delete") {
+		if (!params.tag) return { error: "tag required" };
+		const result = await gh(["release", "delete", params.tag, "--yes"], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		return { data: { status: "success" }, _rendered: `Deleted release ${params.tag}` };
+	}
+
+	if (params.action === "upload") {
+		if (!params.tag || !params.assets || params.assets.length === 0) {
+			return { error: "tag and assets required" };
+		}
+		const result = await gh(["release", "upload", params.tag, ...params.assets], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		return { data: { status: "success" }, _rendered: `Uploaded assets to ${params.tag}` };
+	}
+
+	return { error: `Unknown release action: ${params.action}` };
+}

package/src/operations/log.ts

@@ -0,0 +1,63 @@
+import { parseLog } from "../parsers/log-parser";
+import { renderLog } from "../render";
+import type { Commit, LogParams, LogResult, ToolError, ToolResult } from "../types";
+import { git, parseShortstat } from "../utils";
+
+const LOG_FORMAT = "%H%x00%h%x00%an%x00%ae%x00%aI%x00%cn%x00%ce%x00%cI%x00%P%x00%s%x00%b%x1e";
+
+async function enrichStats(commits: Commit[], cwd?: string): Promise<void> {
+	for (const commit of commits) {
+		const result = await git(["show", "-s", "--shortstat", commit.sha], { cwd });
+		if (result.error) continue;
+		const statLine = result.stdout.split("\n").find((line) => line.includes("files changed"));
+		if (!statLine) continue;
+		const stats = parseShortstat(statLine);
+		if (stats) {
+			commit.stats = {
+				files: stats.files,
+				additions: stats.additions,
+				deletions: stats.deletions,
+			};
+		}
+	}
+}
+
+export async function log(params: LogParams, cwd?: string): Promise<ToolResult<LogResult> | ToolError> {
+	const limit = params.limit ?? 10;
+	const fetchLimit = limit + 1;
+
+	const args = ["log", `--format=${LOG_FORMAT}`, "-n", String(fetchLimit)];
+	if (params.ref) args.push(params.ref);
+	if (params.author) args.push(`--author=${params.author}`);
+	if (params.since) args.push(`--since=${params.since}`);
+	if (params.until) args.push(`--until=${params.until}`);
+	if (params.grep) args.push(`--grep=${params.grep}`);
+	if (params.merges === true) args.push("--merges");
+	if (params.merges === false) args.push("--no-merges");
+	if (params.first_parent) args.push("--first-parent");
+	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 commits = parseLog(result.stdout);
+	const hasMore = commits.length > limit;
+	if (hasMore) commits = commits.slice(0, limit);
+
+	if (params.format && params.format !== "full") {
+		for (const commit of commits) {
+			commit.message = commit.subject;
+		}
+	}
+
+	if (params.stat) {
+		await enrichStats(commits, cwd);
+	}
+
+	const finalResult: LogResult = { commits, hasMore };
+	return { data: finalResult, _rendered: renderLog(finalResult) };
+}

package/src/operations/merge.ts

@@ -0,0 +1,62 @@
+import { GitErrorCode } from "../errors";
+import { renderMerge } from "../render";
+import type { MergeParams, MergeResult, 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 merge(params: MergeParams, cwd?: string): Promise<ToolResult<MergeResult> | ToolError> {
+	if (params.abort) {
+		const result = await git(["merge", "--abort"], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: MergeResult = { status: "success" };
+		return { data, _rendered: renderMerge(data) };
+	}
+
+	if (params.continue) {
+		const result = await git(["merge", "--continue"], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const shaResult = await git(["rev-parse", "HEAD"], { cwd });
+		const data: MergeResult = { status: "success", sha: shaResult.error ? undefined : shaResult.stdout.trim() };
+		return { data, _rendered: renderMerge(data) };
+	}
+
+	const args = ["merge"];
+	if (params.no_ff) args.push("--no-ff");
+	if (params.ff_only) args.push("--ff-only");
+	if (params.squash) args.push("--squash");
+	if (params.message) args.push("-m", params.message);
+	if (!params.ref) {
+		return { error: "Merge ref is required" };
+	}
+	args.push(params.ref);
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		if (result.error.code === GitErrorCode.MERGE_CONFLICT) {
+			const conflicts = await getConflicts(cwd);
+			const data: MergeResult = { status: "conflict", conflicts };
+			return { data, _rendered: renderMerge(data) };
+		}
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
+	let status: MergeResult["status"] = "success";
+	if (output.includes("already up to date")) {
+		status = "up-to-date";
+	} else if (output.includes("fast-forward")) {
+		status = "fast-forward";
+	}
+	const shaResult = await git(["rev-parse", "HEAD"], { cwd });
+	const data: MergeResult = { status, sha: shaResult.error ? undefined : shaResult.stdout.trim() };
+	return { data, _rendered: renderMerge(data) };
+}

package/src/operations/pull.ts

@@ -0,0 +1,47 @@
+import { GitErrorCode } from "../errors";
+import { renderPull } from "../render";
+import type { PullParams, PullResult, 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);
+}
+
+async function countPulledCommits(cwd?: string): Promise<number> {
+	const origResult = await git(["rev-parse", "-q", "--verify", "ORIG_HEAD"], { cwd });
+	if (origResult.error) return 0;
+	const orig = origResult.stdout.trim();
+	const countResult = await git(["rev-list", "--count", `${orig}..HEAD`], { cwd });
+	if (countResult.error) return 0;
+	return Number.parseInt(countResult.stdout.trim(), 10);
+}
+
+export async function pull(params: PullParams, cwd?: string): Promise<ToolResult<PullResult> | ToolError> {
+	const args = ["pull"];
+	if (params.rebase) args.push("--rebase");
+	if (params.ff_only) args.push("--ff-only");
+	if (params.remote) args.push(params.remote);
+	if (params.branch) args.push(params.branch);
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		if (result.error.code === GitErrorCode.MERGE_CONFLICT || result.error.code === GitErrorCode.REBASE_CONFLICT) {
+			const conflicts = await getConflicts(cwd);
+			const data: PullResult = { status: "conflict", conflicts };
+			return { data, _rendered: renderPull(data) };
+		}
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
+	if (output.includes("already up to date")) {
+		const data: PullResult = { status: "up-to-date" };
+		return { data, _rendered: renderPull(data) };
+	}
+
+	const commits = await countPulledCommits(cwd);
+	const data: PullResult = { status: "success", commits };
+	return { data, _rendered: renderPull(data) };
+}

package/src/operations/push.ts

@@ -0,0 +1,59 @@
+import { renderPush } from "../render";
+import type { PushParams, PushResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+async function getCurrentBranch(cwd?: string): Promise<string> {
+	const result = await git(["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+	if (result.error) return "";
+	return result.stdout.trim();
+}
+
+async function hasRemoteRef(remote: string, branch: string, cwd?: string): Promise<boolean> {
+	const result = await git(["rev-parse", "--verify", `refs/remotes/${remote}/${branch}`], { cwd });
+	return !result.error;
+}
+
+async function countCommitsToPush(remote: string, branch: string, hasRemote: boolean, cwd?: string): Promise<number> {
+	if (hasRemote) {
+		const result = await git(["rev-list", "--count", `refs/remotes/${remote}/${branch}..${branch}`], { cwd });
+		if (result.error) return 0;
+		return Number.parseInt(result.stdout.trim(), 10);
+	}
+	const result = await git(["rev-list", "--count", branch], { cwd });
+	if (result.error) return 0;
+	return Number.parseInt(result.stdout.trim(), 10);
+}
+
+export async function push(params: PushParams, cwd?: string): Promise<ToolResult<PushResult> | ToolError> {
+	const remote = params.remote ?? "origin";
+	const branch = params.branch ?? (await getCurrentBranch(cwd));
+	if (!branch) {
+		return { error: "Branch not found", code: "BRANCH_NOT_FOUND" };
+	}
+
+	if (params.delete) {
+		const result = await git(["push", remote, "--delete", branch], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: PushResult = { remote, branch, commits: 0, newBranch: false };
+		return { data, _rendered: renderPush(data) };
+	}
+
+	const hasRemote = await hasRemoteRef(remote, branch, cwd);
+	const commits = await countCommitsToPush(remote, branch, hasRemote, cwd);
+
+	const args = ["push", remote, branch];
+	if (params.set_upstream) args.push("--set-upstream");
+	if (params.tags) args.push("--tags");
+	if (params.force_with_lease) args.push("--force-with-lease");
+	if (params.force) args.push("--force");
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const data: PushResult = { remote, branch, commits, newBranch: !hasRemote };
+	return { data, _rendered: renderPush(data) };
+}

package/src/operations/rebase.ts

@@ -0,0 +1,36 @@
+import { GitErrorCode } from "../errors";
+import { renderRebase } from "../render";
+import type { RebaseParams, RebaseResult, 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 rebase(params: RebaseParams, cwd?: string): Promise<ToolResult<RebaseResult> | ToolError> {
+	const args = ["rebase"];
+	if (params.abort) args.push("--abort");
+	if (params.continue) args.push("--continue");
+	if (params.skip) args.push("--skip");
+	if (!params.abort && !params.continue && !params.skip) {
+		if (params.onto) args.push("--onto", params.onto);
+		if (params.upstream) args.push(params.upstream);
+	}
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		if (result.error.code === GitErrorCode.REBASE_CONFLICT || result.error.code === GitErrorCode.MERGE_CONFLICT) {
+			const conflicts = await getConflicts(cwd);
+			const data: RebaseResult = { status: "conflict", conflicts };
+			return { data, _rendered: renderRebase(data) };
+		}
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
+	const status: RebaseResult["status"] = output.includes("up to date") ? "up-to-date" : "success";
+	const data: RebaseResult = { status };
+	return { data, _rendered: renderRebase(data) };
+}

package/src/operations/restore.ts

@@ -0,0 +1,19 @@
+import { renderRestore } from "../render";
+import type { RestoreParams, RestoreResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+export async function restore(params: RestoreParams, cwd?: string): Promise<ToolResult<RestoreResult> | ToolError> {
+	const args = ["restore"];
+	if (params.staged) args.push("--staged");
+	if (params.worktree) args.push("--worktree");
+	if (params.source) args.push(`--source=${params.source}`);
+	args.push("--", ...params.paths);
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const data: RestoreResult = { restored: params.paths };
+	return { data, _rendered: renderRestore(data) };
+}