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

package/src/operations/diff.ts

@@ -0,0 +1,206 @@
+import { parseDiff } from "../parsers/diff-parser";
+import { renderDiff } from "../render";
+import type { DiffParams, DiffResult, FileDiff, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+interface StatusInfo {
+	status: FileDiff["status"];
+	oldPath?: string;
+}
+
+function parseNameStatus(output: string): Map<string, StatusInfo> {
+	const map = new Map<string, StatusInfo>();
+	for (const line of output.split("\n")) {
+		if (!line) continue;
+		const parts = line.split("\t");
+		const code = parts[0];
+		if (!code) continue;
+		const status = code[0];
+		if (status === "R" || status === "C") {
+			const oldPath = parts[1];
+			const newPath = parts[2];
+			if (newPath) {
+				map.set(newPath, {
+					status: status === "R" ? "renamed" : "copied",
+					oldPath,
+				});
+			}
+			continue;
+		}
+		const path = parts[1];
+		if (!path) continue;
+		const statusMap: Record<string, FileDiff["status"]> = {
+			A: "added",
+			M: "modified",
+			D: "deleted",
+		};
+		map.set(path, { status: statusMap[status] ?? "modified" });
+	}
+	return map;
+}
+
+function parseRenamePath(path: string): { oldPath: string; newPath: string } | null {
+	if (!path.includes("=>")) return null;
+	const braceMatch = path.match(/^(.*)\{(.*) => (.*)\}(.*)$/);
+	if (braceMatch) {
+		const prefix = braceMatch[1];
+		const oldMid = braceMatch[2];
+		const newMid = braceMatch[3];
+		const suffix = braceMatch[4];
+		return {
+			oldPath: `${prefix}${oldMid}${suffix}`,
+			newPath: `${prefix}${newMid}${suffix}`,
+		};
+	}
+	const parts = path.split("=>").map((part) => part.trim());
+	if (parts.length !== 2) return null;
+	return { oldPath: parts[0], newPath: parts[1] };
+}
+
+function parseNumstat(
+	output: string,
+): Map<string, { additions: number; deletions: number; binary: boolean; oldPath?: string }> {
+	const map = new Map<string, { additions: number; deletions: number; binary: boolean; oldPath?: string }>();
+	for (const line of output.split("\n")) {
+		if (!line) continue;
+		const parts = line.split("\t");
+		if (parts.length < 3) continue;
+		const additionsRaw = parts[0];
+		const deletionsRaw = parts[1];
+		const pathRaw = parts.slice(2).join("\t");
+		const additions = additionsRaw === "-" ? 0 : Number.parseInt(additionsRaw, 10);
+		const deletions = deletionsRaw === "-" ? 0 : Number.parseInt(deletionsRaw, 10);
+		const binary = additionsRaw === "-" || deletionsRaw === "-";
+		const rename = parseRenamePath(pathRaw);
+		if (rename) {
+			map.set(rename.newPath, { additions, deletions, binary, oldPath: rename.oldPath });
+			continue;
+		}
+		map.set(pathRaw, { additions, deletions, binary });
+	}
+	return map;
+}
+
+function buildDiffArgs(params: DiffParams): string[] {
+	const args: string[] = ["diff"];
+	if (params.target === "staged") {
+		args.push("--cached");
+	} else if (params.target === "head") {
+		args.push("HEAD");
+	} else if (params.target && typeof params.target === "object") {
+		// Ambiguity: when `to` is omitted, default to diffing against HEAD.
+		const toRef = params.target.to ?? "HEAD";
+		args.push(`${params.target.from}..${toRef}`);
+	}
+
+	if (params.ignore_whitespace) {
+		args.push("--ignore-all-space");
+	}
+	return args;
+}
+
+export async function diff(params: DiffParams, cwd?: string): Promise<ToolResult<DiffResult> | ToolError> {
+	const baseArgs = buildDiffArgs(params);
+	const paths = params.paths ?? [];
+
+	const nameStatusArgs = [...baseArgs, "--name-status"];
+	if (paths.length > 0) nameStatusArgs.push("--", ...paths);
+	const nameStatusResult = await git(nameStatusArgs, { cwd });
+	if (nameStatusResult.error) {
+		return { error: nameStatusResult.error.message, code: nameStatusResult.error.code };
+	}
+	const statusMap = parseNameStatus(nameStatusResult.stdout);
+
+	if (params.name_only || params.stat_only) {
+		const numstatArgs = [...baseArgs, "--numstat"];
+		if (paths.length > 0) numstatArgs.push("--", ...paths);
+		const numstatResult = await git(numstatArgs, { cwd });
+		if (numstatResult.error) {
+			return { error: numstatResult.error.message, code: numstatResult.error.code };
+		}
+		const statsMap = parseNumstat(numstatResult.stdout);
+		const files: FileDiff[] = [];
+		const seen = new Set<string>();
+
+		for (const [path, info] of statusMap.entries()) {
+			const stats = statsMap.get(path);
+			files.push({
+				path,
+				oldPath: info.oldPath ?? stats?.oldPath,
+				status: info.status,
+				binary: stats?.binary ?? false,
+				additions: stats?.additions ?? 0,
+				deletions: stats?.deletions ?? 0,
+			});
+			seen.add(path);
+		}
+
+		for (const [path, stats] of statsMap.entries()) {
+			if (seen.has(path)) continue;
+			files.push({
+				path,
+				oldPath: stats.oldPath,
+				status: "modified",
+				binary: stats.binary,
+				additions: stats.additions,
+				deletions: stats.deletions,
+			});
+		}
+
+		const summary = files.reduce(
+			(acc, file) => {
+				acc.filesChanged += 1;
+				acc.insertions += file.additions;
+				acc.deletions += file.deletions;
+				return acc;
+			},
+			{ filesChanged: 0, insertions: 0, deletions: 0 },
+		);
+
+		const result: DiffResult = {
+			files,
+			stats: summary,
+			truncated: false,
+		};
+		return { data: result, _rendered: renderDiff(result) };
+	}
+
+	const diffArgs = [...baseArgs];
+	if (params.context !== undefined) {
+		diffArgs.push(`--unified=${params.context}`);
+	}
+	if (paths.length > 0) diffArgs.push("--", ...paths);
+
+	const diffResult = await git(diffArgs, { cwd });
+	if (diffResult.error) {
+		return { error: diffResult.error.message, code: diffResult.error.code };
+	}
+
+	const parsed = parseDiff(diffResult.stdout, { maxLines: params.max_lines });
+	for (const file of parsed.files) {
+		const info = statusMap.get(file.path);
+		if (info) {
+			file.status = info.status;
+			file.oldPath = info.oldPath ?? file.oldPath;
+		}
+	}
+
+	const summary = parsed.files.reduce(
+		(acc, file) => {
+			acc.filesChanged += 1;
+			acc.insertions += file.additions;
+			acc.deletions += file.deletions;
+			return acc;
+		},
+		{ filesChanged: 0, insertions: 0, deletions: 0 },
+	);
+
+	const result: DiffResult = {
+		files: parsed.files,
+		stats: summary,
+		truncated: parsed.truncated,
+		truncatedFiles: parsed.truncatedFiles.length > 0 ? parsed.truncatedFiles : undefined,
+	};
+
+	return { data: result, _rendered: renderDiff(result) };
+}

package/src/operations/fetch.ts

@@ -0,0 +1,49 @@
+import { renderFetch } from "../render";
+import type { FetchParams, FetchResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+async function getRemoteRefs(remote: string, branch?: string, cwd?: string): Promise<Map<string, string>> {
+	const refPrefix = branch ? `refs/remotes/${remote}/${branch}` : `refs/remotes/${remote}`;
+	const result = await git(["for-each-ref", refPrefix, "--format=%(refname)\t%(objectname)"], { cwd });
+	if (result.error) return new Map();
+	const map = new Map<string, string>();
+	for (const line of result.stdout.split("\n")) {
+		if (!line) continue;
+		const [ref, sha] = line.split("\t");
+		if (ref && sha) map.set(ref, sha);
+	}
+	return map;
+}
+
+export async function fetch(params: FetchParams, cwd?: string): Promise<ToolResult<FetchResult> | ToolError> {
+	const remote = params.remote ?? "origin";
+	const before = await getRemoteRefs(remote, params.branch, cwd);
+
+	const args = ["fetch"];
+	if (params.all) {
+		args.push("--all");
+	} else {
+		args.push(remote);
+		if (params.branch) args.push(params.branch);
+	}
+	if (params.prune) args.push("--prune");
+	if (params.tags) args.push("--tags");
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const after = await getRemoteRefs(remote, params.branch, cwd);
+	const updated: FetchResult["updated"] = [];
+	for (const [ref, newSha] of after.entries()) {
+		const oldSha = before.get(ref);
+		if (!oldSha || oldSha !== newSha) {
+			updated.push({ ref, oldSha: oldSha ?? "", newSha });
+		}
+	}
+	const pruned = params.prune ? Array.from(before.keys()).filter((ref) => !after.has(ref)) : undefined;
+
+	const data: FetchResult = { updated, ...(pruned && pruned.length > 0 ? { pruned } : {}) };
+	return { data, _rendered: renderFetch(data) };
+}

package/src/operations/github/ci.ts

@@ -0,0 +1,155 @@
+import type {
+	CIActionResult,
+	CIParams,
+	CIResult,
+	JobInfo,
+	RunInfo,
+	RunListResult,
+	RunViewResult,
+	ToolError,
+	ToolResult,
+} from "../../types";
+import { gh } from "../../utils";
+
+type GhRun = {
+	databaseId?: number;
+	id?: number;
+	displayTitle?: string;
+	name?: string;
+	status: RunInfo["status"];
+	conclusion?: RunInfo["conclusion"];
+	headBranch?: string;
+	branch?: string;
+	headSha?: string;
+	sha?: string;
+	url: string;
+	createdAt: string;
+	updatedAt: string;
+	jobs?: GhJob[];
+};
+
+type GhJob = {
+	databaseId?: number;
+	id?: number;
+	name: string;
+	status: string;
+	conclusion?: string;
+	steps?: Array<{ name: string; status: string; conclusion?: string }>;
+};
+
+function mapRunInfo(raw: GhRun): RunInfo {
+	return {
+		id: raw.databaseId ?? raw.id ?? 0,
+		name: raw.displayTitle ?? raw.name ?? "",
+		status: raw.status,
+		conclusion: raw.conclusion ?? undefined,
+		branch: raw.headBranch ?? raw.branch ?? "",
+		sha: raw.headSha ?? raw.sha ?? "",
+		url: raw.url,
+		createdAt: raw.createdAt,
+		updatedAt: raw.updatedAt,
+	};
+}
+
+function mapJobInfo(raw: GhJob): JobInfo {
+	return {
+		id: raw.databaseId ?? raw.id ?? 0,
+		name: raw.name,
+		status: raw.status,
+		conclusion: raw.conclusion ?? undefined,
+		steps: (raw.steps ?? []).map((step) => ({
+			name: step.name,
+			status: step.status,
+			conclusion: step.conclusion ?? undefined,
+		})),
+	};
+}
+
+export async function ci(params: CIParams, cwd?: string): Promise<ToolResult<CIResult> | ToolError> {
+	if (params.action === "list") {
+		const args = [
+			"run",
+			"list",
+			"--json",
+			"databaseId,displayTitle,status,conclusion,headBranch,headSha,url,createdAt,updatedAt",
+		];
+		if (params.limit) args.push("--limit", String(params.limit));
+		if (params.branch) args.push("--branch", params.branch);
+		if (params.workflow) args.push("--workflow", params.workflow);
+		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 GhRun[];
+		const runs = raw.map((item) => mapRunInfo(item));
+		const data: RunListResult = { runs };
+		return { data, _rendered: `Runs: ${runs.length}` };
+	}
+
+	if (params.action === "view") {
+		if (!params.run_id) {
+			return { error: "run_id required" };
+		}
+		const result = await gh(
+			[
+				"run",
+				"view",
+				String(params.run_id),
+				"--json",
+				"databaseId,name,status,conclusion,headBranch,headSha,url,createdAt,updatedAt,jobs",
+			],
+			{ cwd },
+		);
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const raw = JSON.parse(result.stdout) as GhRun;
+		const run = mapRunInfo(raw);
+		const jobs: JobInfo[] = (raw.jobs ?? []).map((job) => mapJobInfo(job));
+		let logs: string | undefined;
+		if (params.logs_failed) {
+			const logsResult = await gh(["run", "view", String(params.run_id), "--log-failed"], { cwd });
+			if (!logsResult.error) logs = logsResult.stdout;
+		}
+		const data: RunViewResult = { run, jobs, ...(logs ? { logs } : {}) };
+		return { data, _rendered: `Run ${run.id} ${run.status}` };
+	}
+
+	if (params.action === "watch") {
+		if (!params.run_id) return { error: "run_id required" };
+		const result = await gh(["run", "watch", String(params.run_id), "--exit-status"], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: CIActionResult = { status: "success" };
+		return { data, _rendered: `Watched run ${params.run_id}` };
+	}
+
+	if (params.action === "run") {
+		if (!params.workflow) return { error: "workflow required" };
+		const args = ["workflow", "run", params.workflow];
+		if (params.inputs) {
+			for (const [key, value] of Object.entries(params.inputs)) {
+				args.push("--field", `${key}=${value}`);
+			}
+		}
+		const result = await gh(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: CIActionResult = { status: "success" };
+		return { data, _rendered: `Triggered workflow ${params.workflow}` };
+	}
+
+	if (params.action === "cancel" || params.action === "rerun") {
+		if (!params.run_id) return { error: "run_id required" };
+		const result = await gh(["run", params.action, String(params.run_id)], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: CIActionResult = { status: "success" };
+		return { data, _rendered: `${params.action} run ${params.run_id}` };
+	}
+
+	return { error: `Unknown CI action: ${params.action}` };
+}

package/src/operations/github/issue.ts

@@ -0,0 +1,132 @@
+import type {
+	IssueCreateResult,
+	IssueInfo,
+	IssueListResult,
+	IssueParams,
+	IssueResult,
+	ToolError,
+	ToolResult,
+} from "../../types";
+import { gh } from "../../utils";
+
+type GhIssue = {
+	number: number;
+	title: string;
+	state: string;
+	author?: { login?: string } | string;
+	body?: string | null;
+	labels?: Array<{ name?: string } | string>;
+	assignees?: Array<{ login?: string } | string>;
+	url: string;
+	createdAt: string;
+	comments?: number;
+};
+
+function mapIssueInfo(raw: GhIssue): IssueInfo {
+	const author = typeof raw.author === "string" ? raw.author : (raw.author?.login ?? "");
+	return {
+		number: raw.number,
+		title: raw.title,
+		state: raw.state,
+		author,
+		body: raw.body ?? "",
+		labels: (raw.labels ?? [])
+			.map((label) => (typeof label === "string" ? label : (label.name ?? "")))
+			.filter(Boolean),
+		assignees: (raw.assignees ?? [])
+			.map((assignee) => (typeof assignee === "string" ? assignee : (assignee.login ?? "")))
+			.filter(Boolean),
+		url: raw.url,
+		createdAt: raw.createdAt,
+		comments: raw.comments ?? 0,
+	};
+}
+
+export async function issue(params: IssueParams, cwd?: string): Promise<ToolResult<IssueResult> | ToolError> {
+	if (params.action === "list") {
+		const args = [
+			"issue",
+			"list",
+			"--json",
+			"number,title,state,author,body,labels,assignees,url,createdAt,comments",
+		];
+		if (params.state) args.push("--state", params.state);
+		if (params.labels && params.labels.length > 0) args.push("--label", params.labels.join(","));
+		if (params.assignee) args.push("--assignee", params.assignee);
+		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 GhIssue[];
+		const issues = raw.map((item) => mapIssueInfo(item));
+		const data: IssueListResult = { issues };
+		return { data, _rendered: `Issues: ${issues.length}` };
+	}
+
+	if (params.action === "view") {
+		if (!params.number) {
+			return { error: "Issue number required" };
+		}
+		const result = await gh(
+			[
+				"issue",
+				"view",
+				String(params.number),
+				"--json",
+				"number,title,state,author,body,labels,assignees,url,createdAt,comments",
+			],
+			{ cwd },
+		);
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const issueInfo = mapIssueInfo(JSON.parse(result.stdout) as GhIssue);
+		return { data: { issue: issueInfo }, _rendered: `Issue #${issueInfo.number}: ${issueInfo.title}` };
+	}
+
+	if (params.action === "create") {
+		const args = ["issue", "create"];
+		if (params.title) args.push("--title", params.title);
+		if (params.body) args.push("--body", params.body);
+		const result = await gh(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		let number = 0;
+		let url = "";
+		const match = result.stdout.match(/https?:\/\/\S+/);
+		if (match) {
+			url = match[0];
+			const numMatch = url.match(/issues\/(\d+)/);
+			if (numMatch) number = Number.parseInt(numMatch[1], 10);
+		}
+		const data: IssueCreateResult = { number, url };
+		return { data, _rendered: url ? `Created issue ${url}` : "Created issue" };
+	}
+
+	if (params.action === "close" || params.action === "reopen") {
+		if (!params.number) {
+			return { error: "Issue number required" };
+		}
+		const result = await gh(["issue", params.action, String(params.number)], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const verb = params.action === "close" ? "Closed" : "Reopened";
+		return { data: { status: "success" }, _rendered: `${verb} issue #${params.number}` };
+	}
+
+	if (params.action === "comment") {
+		if (!params.number || !params.comment_body) {
+			return { error: "Issue number and comment_body required" };
+		}
+		const result = await gh(["issue", "comment", String(params.number), "--body", params.comment_body], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		return { data: { status: "success" }, _rendered: `Commented on issue #${params.number}` };
+	}
+
+	return { error: `Unknown issue action: ${params.action}` };
+}