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

package/src/operations/show.ts

@@ -0,0 +1,102 @@
+import { parseDiff } from "../parsers/diff-parser";
+import { parseLog } from "../parsers/log-parser";
+import { renderShowCommit, renderShowFile } from "../render";
+import type { ShowCommitResult, ShowFileResult, ShowParams, ToolError, ToolResult } from "../types";
+import { git } 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";
+
+const MAX_SHOW_LINES = 2000;
+const MAX_SHOW_BYTES = 200_000;
+
+export async function show(
+	params: ShowParams,
+	cwd?: string,
+): Promise<ToolResult<ShowCommitResult | ShowFileResult> | ToolError> {
+	if (params.path) {
+		const result = await git(["show", `${params.ref}:${params.path}`], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+
+		let content = result.stdout;
+		let truncated = false;
+
+		// Ambiguity: no truncation limits specified for show file; defaulting to 2000 lines or 200KB.
+		if (content.length > MAX_SHOW_BYTES) {
+			content = content.slice(0, MAX_SHOW_BYTES);
+			truncated = true;
+		}
+
+		let lines = content.split("\n");
+		if (lines.length > MAX_SHOW_LINES) {
+			lines = lines.slice(0, MAX_SHOW_LINES);
+			content = lines.join("\n");
+			truncated = true;
+		}
+
+		if (params.lines) {
+			const start = Math.max(1, params.lines.start);
+			const end = Math.max(start, params.lines.end);
+			const slice = lines.slice(start - 1, end);
+			content = slice.join("\n");
+			truncated = false;
+		}
+
+		const data: ShowFileResult = {
+			path: params.path,
+			ref: params.ref,
+			content,
+			truncated,
+		};
+		return { data, _rendered: renderShowFile(data) };
+	}
+
+	const commitResult = await git(["show", "-s", `--format=${LOG_FORMAT}`, params.ref], { cwd });
+	if (commitResult.error) {
+		return { error: commitResult.error.message, code: commitResult.error.code };
+	}
+	const commits = parseLog(commitResult.stdout);
+	const commit = commits[0];
+	if (!commit) {
+		return { error: "Commit not found", code: "REF_NOT_FOUND" };
+	}
+
+	let diffData: ShowCommitResult["diff"] | undefined;
+	if (params.diff || params.stat) {
+		const diffResult = await git(["show", params.ref, "--format="], { cwd });
+		if (diffResult.error) {
+			return { error: diffResult.error.message, code: diffResult.error.code };
+		}
+		const parsed = parseDiff(diffResult.stdout);
+		const files = parsed.files.map((file) => {
+			if (!params.diff) {
+				delete file.hunks;
+			}
+			return file;
+		});
+		const stats = files.reduce(
+			(acc, file) => {
+				acc.filesChanged += 1;
+				acc.insertions += file.additions;
+				acc.deletions += file.deletions;
+				return acc;
+			},
+			{ filesChanged: 0, insertions: 0, deletions: 0 },
+		);
+		const diff: ShowCommitResult["diff"] = {
+			files,
+			stats,
+			truncated: parsed.truncated,
+			truncatedFiles: parsed.truncatedFiles.length > 0 ? parsed.truncatedFiles : undefined,
+		};
+		diffData = diff;
+	}
+
+	const data: ShowCommitResult = {
+		commit,
+		...(diffData ? { diff: diffData } : {}),
+	};
+
+	return { data, _rendered: renderShowCommit(data) };
+}

package/src/operations/stash.ts

@@ -0,0 +1,86 @@
+import type { StashEntry, StashParams, StashResult, ToolError, ToolResult } from "../types";
+import { git, parseShortstat } from "../utils";
+
+function parseStashIndex(ref: string): number {
+	const match = ref.match(/stash@\{(\d+)\}/);
+	return match ? Number.parseInt(match[1], 10) : -1;
+}
+
+function parseBranch(subject: string): string {
+	const match = subject.match(/on ([^:]+):/i);
+	return match ? match[1] : "";
+}
+
+export async function stash(params: StashParams, cwd?: string): Promise<ToolResult<StashResult> | ToolError> {
+	const action = params.action ?? "list";
+
+	if (action === "list") {
+		const result = await git(["stash", "list", "--date=iso-strict", "--format=%gd%x00%gs%x00%cd"], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const stashes: StashEntry[] = [];
+		for (const line of result.stdout.split("\n")) {
+			if (!line) continue;
+			const parts = line.split("\x00");
+			if (parts.length < 3) continue;
+			const ref = parts[0];
+			const message = parts[1];
+			const date = parts[2];
+			stashes.push({
+				index: parseStashIndex(ref),
+				message,
+				branch: parseBranch(message),
+				date,
+			});
+		}
+		return { data: { stashes }, _rendered: `Stashes: ${stashes.length}` };
+	}
+
+	if (action === "show") {
+		const index = params.index ?? 0;
+		const ref = `stash@{${index}}`;
+		const statResult = await git(["stash", "show", "--shortstat", ref], { cwd });
+		if (statResult.error) {
+			return { error: statResult.error.message, code: statResult.error.code };
+		}
+		const statLine = statResult.stdout.split("\n").find((line) => line.includes("files changed"));
+		const statsParsed = statLine ? parseShortstat(statLine) : null;
+		const stats = {
+			files: statsParsed?.files ?? 0,
+			additions: statsParsed?.additions ?? 0,
+			deletions: statsParsed?.deletions ?? 0,
+		};
+		const filesResult = await git(["stash", "show", "--name-only", ref], { cwd });
+		if (filesResult.error) {
+			return { error: filesResult.error.message, code: filesResult.error.code };
+		}
+		const files = filesResult.stdout.split("\n").filter(Boolean);
+		return { data: { stats, files }, _rendered: `Stash ${index} (${files.length} files)` };
+	}
+
+	if (action === "push") {
+		const args = ["stash", "push"];
+		if (params.message) args.push("-m", params.message);
+		if (params.include_untracked) args.push("-u");
+		if (params.keep_index) args.push("--keep-index");
+		const result = await git(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		return { data: { status: "success" }, _rendered: "Stash saved" };
+	}
+
+	if (action === "pop" || action === "apply" || action === "drop") {
+		const index = params.index ?? 0;
+		const ref = `stash@{${index}}`;
+		const args = ["stash", action, ref];
+		const result = await git(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		return { data: { status: "success" }, _rendered: `Stash ${action} ${index}` };
+	}
+
+	return { error: `Unknown stash action: ${action}` };
+}

package/src/operations/status.ts

@@ -0,0 +1,54 @@
+import { parseStatus } from "../parsers/status-parser";
+import { renderStatus } from "../render";
+import type { StatusParams, StatusResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+export async function status(params: StatusParams, cwd?: string): Promise<ToolResult<StatusResult> | ToolError> {
+	const args = ["status", "--porcelain=v2", "--branch", "--ahead-behind"];
+	if (params.ignored) args.push("--ignored");
+
+	const result = await git(args, { cwd });
+	if (result.error) {
+		return { error: result.error.message, code: result.error.code };
+	}
+
+	const parsed = parseStatus(result.stdout, Boolean(params.ignored));
+	let finalResult = parsed;
+
+	if (params.only) {
+		const base: StatusResult = {
+			branch: parsed.branch,
+			upstream: parsed.upstream,
+			ahead: parsed.ahead,
+			behind: parsed.behind,
+			staged: [],
+			modified: [],
+			untracked: [],
+			conflicts: [],
+		};
+		switch (params.only) {
+			case "branch":
+				finalResult = base;
+				break;
+			case "modified":
+				finalResult = { ...base, modified: parsed.modified };
+				break;
+			case "staged":
+				finalResult = { ...base, staged: parsed.staged };
+				break;
+			case "untracked":
+				finalResult = { ...base, untracked: parsed.untracked };
+				break;
+			case "conflicts":
+				finalResult = { ...base, conflicts: parsed.conflicts };
+				break;
+			case "sync":
+				finalResult = base;
+				break;
+			default:
+				finalResult = parsed;
+		}
+	}
+
+	return { data: finalResult, _rendered: renderStatus(finalResult) };
+}

package/src/operations/tag.ts

@@ -0,0 +1,79 @@
+import { renderTag } from "../render";
+import type { TagInfo, TagParams, TagResult, ToolError, ToolResult } from "../types";
+import { git } from "../utils";
+
+export async function tag(params: TagParams, cwd?: string): Promise<ToolResult<TagResult> | ToolError> {
+	const action = params.action ?? "list";
+
+	if (action === "list") {
+		const result = await git(
+			[
+				"for-each-ref",
+				"refs/tags",
+				"--format=%(refname:short)%x00%(objectname)%x00%(taggername)%x00%(taggerdate:iso-strict)%x00%(subject)%x00%(objecttype)",
+			],
+			{ cwd },
+		);
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const tags: TagInfo[] = [];
+		for (const line of result.stdout.split("\n")) {
+			if (!line) continue;
+			const parts = line.split("\x00");
+			if (parts.length < 6) continue;
+			const [name, sha, taggerName, taggerDate, subject, objectType] = parts;
+			const annotated = objectType === "tag";
+			const tagger = taggerName && taggerDate ? { name: taggerName, date: taggerDate } : undefined;
+			tags.push({ name, sha, message: subject || undefined, tagger, annotated });
+		}
+		const data: TagResult = { tags };
+		return { data, _rendered: renderTag(data) };
+	}
+
+	if (action === "create") {
+		if (!params.name) {
+			return { error: "Tag name required" };
+		}
+		const args = ["tag"];
+		if (params.force) args.push("-f");
+		if (params.sign) args.push("-s");
+		if (params.message) {
+			args.push("-a", "-m", params.message);
+		}
+		args.push(params.name);
+		if (params.ref) args.push(params.ref);
+		const result = await git(args, { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: TagResult = { status: "success" };
+		return { data, _rendered: renderTag(data) };
+	}
+
+	if (action === "delete") {
+		if (!params.name) {
+			return { error: "Tag name required" };
+		}
+		const result = await git(["tag", "-d", params.name], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: TagResult = { status: "success" };
+		return { data, _rendered: renderTag(data) };
+	}
+
+	if (action === "push") {
+		if (!params.name) {
+			return { error: "Tag name required" };
+		}
+		const result = await git(["push", "origin", params.name], { cwd });
+		if (result.error) {
+			return { error: result.error.message, code: result.error.code };
+		}
+		const data: TagResult = { status: "success" };
+		return { data, _rendered: renderTag(data) };
+	}
+
+	return { error: `Unknown tag action: ${action}` };
+}

package/src/parsers/blame-parser.ts

@@ -0,0 +1,91 @@
+import type { BlameLine } from "../types";
+
+interface BlameMeta {
+	sha: string;
+	shortSha: string;
+	author: string;
+	date: string;
+	lineNo: number;
+	original?: { sha: string; path: string; lineNo: number };
+}
+
+function formatDate(timestamp: string): string {
+	const seconds = Number.parseInt(timestamp, 10);
+	if (!Number.isFinite(seconds)) return "";
+	return new Date(seconds * 1000).toISOString();
+}
+
+export function parseBlame(output: string): BlameLine[] {
+	const lines = output.split("\n");
+	const result: BlameLine[] = [];
+	let current: BlameMeta | null = null;
+	let remaining = 0;
+	let currentFilename = "";
+
+	for (const line of lines) {
+		if (!line) continue;
+		if (line.startsWith("\t")) {
+			if (!current) continue;
+			result.push({
+				lineNo: current.lineNo,
+				sha: current.sha,
+				shortSha: current.shortSha,
+				author: current.author,
+				date: current.date,
+				content: line.slice(1),
+				original: current.original,
+			});
+			current.lineNo += 1;
+			remaining -= 1;
+			if (remaining <= 0) {
+				current = null;
+			}
+			continue;
+		}
+
+		const headerMatch = line.match(/^([0-9a-f]{40}) (\d+) (\d+) (\d+)/);
+		if (headerMatch) {
+			const sha = headerMatch[1];
+			const finalLine = Number.parseInt(headerMatch[3], 10);
+			remaining = Number.parseInt(headerMatch[4], 10);
+			current = {
+				sha,
+				shortSha: sha.slice(0, 7),
+				author: "",
+				date: "",
+				lineNo: finalLine,
+			};
+			continue;
+		}
+
+		if (!current) continue;
+
+		if (line.startsWith("author ")) {
+			current.author = line.slice(7).trim();
+			continue;
+		}
+		if (line.startsWith("author-time ")) {
+			current.date = formatDate(line.slice(12).trim());
+			continue;
+		}
+		if (line.startsWith("previous ")) {
+			const parts = line.split(" ");
+			if (parts.length >= 3) {
+				current.original = {
+					sha: parts[1],
+					path: currentFilename,
+					lineNo: current.lineNo,
+				};
+			}
+			continue;
+		}
+		if (line.startsWith("filename ")) {
+			currentFilename = line.slice(9).trim();
+			if (current.original) {
+				current.original.path = currentFilename;
+			}
+		}
+	}
+
+	return result;
+}

package/src/parsers/diff-parser.ts

@@ -0,0 +1,162 @@
+import type { DiffLine, FileDiff, Hunk } from "../types";
+
+export interface DiffParseResult {
+	files: FileDiff[];
+	truncated: boolean;
+	truncatedFiles: string[];
+}
+
+export interface DiffParseOptions {
+	maxLines?: number;
+}
+
+function parseHunkHeader(header: string): { oldStart: number; oldCount: number; newStart: number; newCount: number } {
+	const match = header.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+	if (!match) {
+		return { oldStart: 0, oldCount: 0, newStart: 0, newCount: 0 };
+	}
+	return {
+		oldStart: Number.parseInt(match[1], 10),
+		oldCount: Number.parseInt(match[2] ?? "1", 10),
+		newStart: Number.parseInt(match[3], 10),
+		newCount: Number.parseInt(match[4] ?? "1", 10),
+	};
+}
+
+export function parseDiff(raw: string, options?: DiffParseOptions): DiffParseResult {
+	const maxLines = options?.maxLines ?? Number.POSITIVE_INFINITY;
+	const lines = raw.split("\n");
+	const files: FileDiff[] = [];
+	const truncatedFiles: string[] = [];
+	let truncated = false;
+	let lineCount = 0;
+
+	let current: FileDiff | null = null;
+	let currentHunk: Hunk | null = null;
+	let oldLine = 0;
+	let newLine = 0;
+
+	const finalizeHunk = () => {
+		if (current && currentHunk) {
+			current.hunks = current.hunks ?? [];
+			current.hunks.push(currentHunk);
+			currentHunk = null;
+		}
+	};
+
+	const finalizeFile = () => {
+		finalizeHunk();
+		if (current) {
+			files.push(current);
+			current = null;
+		}
+	};
+
+	for (const line of lines) {
+		if (line.startsWith("diff --git ")) {
+			finalizeFile();
+			const match = line.match(/^diff --git a\/(.*) b\/(.*)$/);
+			const path = match ? match[2] : line.slice("diff --git ".length).trim();
+			const oldPath = match ? match[1] : undefined;
+			current = {
+				path,
+				oldPath,
+				status: "modified",
+				binary: false,
+				additions: 0,
+				deletions: 0,
+			};
+			continue;
+		}
+
+		if (!current) continue;
+
+		if (line.startsWith("new file mode")) {
+			current.status = "added";
+			continue;
+		}
+		if (line.startsWith("deleted file mode")) {
+			current.status = "deleted";
+			continue;
+		}
+		if (line.startsWith("rename from ")) {
+			current.status = "renamed";
+			current.oldPath = line.slice("rename from ".length).trim();
+			continue;
+		}
+		if (line.startsWith("rename to ")) {
+			current.path = line.slice("rename to ".length).trim();
+			continue;
+		}
+		if (line.startsWith("copy from ")) {
+			current.status = "copied";
+			current.oldPath = line.slice("copy from ".length).trim();
+			continue;
+		}
+		if (line.startsWith("copy to ")) {
+			current.path = line.slice("copy to ".length).trim();
+			continue;
+		}
+		if (line.startsWith("Binary files ") || line.startsWith("GIT binary patch")) {
+			current.binary = true;
+			continue;
+		}
+
+		if (line.startsWith("@@ ")) {
+			finalizeHunk();
+			const header = line;
+			const ranges = parseHunkHeader(header);
+			currentHunk = {
+				oldStart: ranges.oldStart,
+				oldCount: ranges.oldCount,
+				newStart: ranges.newStart,
+				newCount: ranges.newCount,
+				header,
+				lines: [],
+			};
+			oldLine = ranges.oldStart;
+			newLine = ranges.newStart;
+			continue;
+		}
+
+		if (!currentHunk) {
+			continue;
+		}
+
+		if (lineCount >= maxLines) {
+			if (!truncated) {
+				truncated = true;
+				truncatedFiles.push(current.path);
+			}
+			continue;
+		}
+
+		if (line.startsWith("\\")) {
+			continue;
+		}
+
+		let diffLine: DiffLine | null = null;
+		if (line.startsWith("+") && !line.startsWith("+++")) {
+			diffLine = { type: "add", content: line.slice(1), newLineNo: newLine };
+			newLine += 1;
+			current.additions += 1;
+		} else if (line.startsWith("-") && !line.startsWith("---")) {
+			diffLine = { type: "delete", content: line.slice(1), oldLineNo: oldLine };
+			oldLine += 1;
+			current.deletions += 1;
+		} else if (line.startsWith(" ")) {
+			diffLine = { type: "context", content: line.slice(1), oldLineNo: oldLine, newLineNo: newLine };
+			oldLine += 1;
+			newLine += 1;
+		}
+
+		if (diffLine) {
+			currentHunk.lines.push(diffLine);
+			lineCount += 1;
+		}
+	}
+
+	finalizeFile();
+
+	return { files, truncated, truncatedFiles };
+}

package/src/parsers/log-parser.ts

@@ -0,0 +1,43 @@
+import type { Commit } from "../types";
+
+const RECORD_SEPARATOR = "\x1e";
+const FIELD_SEPARATOR = "\x00";
+
+export function parseLog(output: string): Commit[] {
+	const records = output.split(RECORD_SEPARATOR).filter((record) => record.trim().length > 0);
+	const commits: Commit[] = [];
+
+	for (const record of records) {
+		const fields = record.split(FIELD_SEPARATOR);
+		if (fields.length < 11) continue;
+
+		const [
+			sha,
+			shortSha,
+			authorName,
+			authorEmail,
+			authorDate,
+			committerName,
+			committerEmail,
+			committerDate,
+			parentsRaw,
+			subject,
+			body,
+		] = fields;
+
+		const message = body ? `${subject}\n\n${body}` : subject;
+		const parents = parentsRaw ? parentsRaw.split(" ").filter(Boolean) : [];
+
+		commits.push({
+			sha,
+			shortSha,
+			author: { name: authorName, email: authorEmail, date: authorDate },
+			committer: { name: committerName, email: committerEmail, date: committerDate },
+			message,
+			subject,
+			parents,
+		});
+	}
+
+	return commits;
+}