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

package/src/parsers/status-parser.ts

@@ -0,0 +1,93 @@
+import type { FileStatus, StatusResult } from "../types";
+
+function mapStatus(code: string, path: string, oldPath?: string): FileStatus {
+	const statusMap: Record<string, FileStatus["status"]> = {
+		A: "added",
+		M: "modified",
+		D: "deleted",
+		R: "renamed",
+		C: "copied",
+		T: "modified",
+		U: "modified",
+	};
+	return { path, status: statusMap[code] ?? "modified", oldPath };
+}
+
+export function parseStatus(output: string, includeIgnored: boolean): StatusResult {
+	const lines = output.split("\n");
+	const result: StatusResult = {
+		branch: "",
+		upstream: null,
+		ahead: 0,
+		behind: 0,
+		staged: [],
+		modified: [],
+		untracked: [],
+		conflicts: [],
+	};
+	if (includeIgnored) {
+		result.ignored = [];
+	}
+
+	for (const line of lines) {
+		if (line.startsWith("# branch.head ")) {
+			result.branch = line.slice(14).trim();
+			continue;
+		}
+		if (line.startsWith("# branch.upstream ")) {
+			result.upstream = line.slice(18).trim();
+			continue;
+		}
+		if (line.startsWith("# branch.ab ")) {
+			const match = line.match(/\+(\d+) -?(\d+)/);
+			if (match) {
+				result.ahead = Number.parseInt(match[1], 10);
+				result.behind = Number.parseInt(match[2] ?? "0", 10);
+			}
+			continue;
+		}
+
+		if (line.startsWith("1 ") || line.startsWith("2 ")) {
+			const parts = line.split(" ");
+			const xy = parts[1];
+			let path = parts.slice(-1)[0] ?? "";
+			let oldPath: string | undefined;
+
+			if (line.startsWith("2 ")) {
+				const [beforeTab, afterTab] = line.split("\t");
+				if (afterTab) {
+					const preParts = beforeTab.split(" ");
+					path = preParts[preParts.length - 1];
+					oldPath = afterTab.trim();
+				}
+			}
+
+			if (xy[0] !== ".") {
+				result.staged.push(mapStatus(xy[0], path, oldPath));
+			}
+			if (xy[1] !== ".") {
+				result.modified.push(mapStatus(xy[1], path, oldPath));
+			}
+			continue;
+		}
+
+		if (line.startsWith("u ")) {
+			const path = line.split(" ").slice(-1)[0];
+			if (path) {
+				result.conflicts.push(path);
+			}
+			continue;
+		}
+
+		if (line.startsWith("? ")) {
+			result.untracked.push(line.slice(2));
+			continue;
+		}
+
+		if (includeIgnored && line.startsWith("! ")) {
+			result.ignored?.push(line.slice(2));
+		}
+	}
+
+	return result;
+}

package/src/render.ts

@@ -0,0 +1,181 @@
+import type {
+	AddResult,
+	BlameResult,
+	BranchListResult,
+	CherryPickResult,
+	CommitResult,
+	DiffResult,
+	FetchResult,
+	LogResult,
+	MergeResult,
+	PullResult,
+	PushResult,
+	RebaseResult,
+	ReleaseResult,
+	RestoreResult,
+	ShowCommitResult,
+	ShowFileResult,
+	StatusResult,
+	TagResult,
+} from "./types";
+
+function renderFileList(title: string, files: string[]): string {
+	if (files.length === 0) return "";
+	return `${title}:\n${files.map((file) => `- ${file}`).join("\n")}`;
+}
+
+export function renderStatus(result: StatusResult): string {
+	const parts: string[] = [];
+	const sync = result.upstream
+		? `(upstream ${result.upstream}, ahead ${result.ahead}, behind ${result.behind})`
+		: "(no upstream)";
+	parts.push(`Branch: ${result.branch} ${sync}`);
+
+	if (result.staged.length > 0) {
+		parts.push(
+			`Staged (${result.staged.length}):\n${result.staged
+				.map((file) => `- ${file.path} (${file.status})`)
+				.join("\n")}`,
+		);
+	}
+	if (result.modified.length > 0) {
+		parts.push(
+			`Modified (${result.modified.length}):\n${result.modified
+				.map((file) => `- ${file.path} (${file.status})`)
+				.join("\n")}`,
+		);
+	}
+	if (result.untracked.length > 0) {
+		parts.push(renderFileList(`Untracked (${result.untracked.length})`, result.untracked));
+	}
+	if (result.conflicts.length > 0) {
+		parts.push(renderFileList(`Conflicts (${result.conflicts.length})`, result.conflicts));
+	}
+	if (result.ignored && result.ignored.length > 0) {
+		parts.push(renderFileList(`Ignored (${result.ignored.length})`, result.ignored));
+	}
+
+	return parts.join("\n\n");
+}
+
+export function renderDiff(result: DiffResult): string {
+	const header = `${result.stats.filesChanged} files changed, ${result.stats.insertions} insertions(+), ${result.stats.deletions} deletions(-)`;
+	const files = result.files.map((file) => {
+		const status = file.status.toUpperCase();
+		return `- ${status} ${file.path} (+${file.additions}/-${file.deletions})`;
+	});
+	const truncatedNote = result.truncated ? "\n\nDiff output truncated." : "";
+	return [header, ...files].join("\n") + truncatedNote;
+}
+
+export function renderLog(result: LogResult): string {
+	if (result.commits.length === 0) return "No commits found.";
+	const lines = result.commits.map((commit) => `${commit.shortSha} ${commit.subject}`);
+	const more = result.hasMore ? "\n(more commits available)" : "";
+	return lines.join("\n") + more;
+}
+
+export function renderShowCommit(result: ShowCommitResult): string {
+	const commit = result.commit;
+	const header = `${commit.shortSha} ${commit.subject}`;
+	if (!result.diff) return header;
+	return `${header}\n\n${renderDiff(result.diff)}`;
+}
+
+export function renderShowFile(result: ShowFileResult): string {
+	const truncated = result.truncated ? "\n\n[truncated]" : "";
+	return `${result.content}${truncated}`;
+}
+
+export function renderBlame(result: BlameResult): string {
+	return result.lines.map((line) => `${line.shortSha} ${line.lineNo} ${line.author}: ${line.content}`).join("\n");
+}
+
+export function renderBranchList(result: BranchListResult): string {
+	const lines: string[] = [];
+	lines.push(`Current: ${result.current}`);
+	lines.push("Local:");
+	for (const branch of result.local) {
+		const track = branch.upstream
+			? ` (${branch.upstream} ahead ${branch.ahead ?? 0} behind ${branch.behind ?? 0}${branch.gone ? ", gone" : ""})`
+			: "";
+		lines.push(`- ${branch.name}${track}`);
+	}
+	if (result.remote && result.remote.length > 0) {
+		lines.push("Remote:");
+		for (const branch of result.remote) {
+			lines.push(`- ${branch.name}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+export function renderAdd(result: AddResult): string {
+	return `Staged ${result.staged.length} files`;
+}
+
+export function renderRestore(result: RestoreResult): string {
+	return `Restored ${result.restored.length} files`;
+}
+
+export function renderCommit(result: CommitResult): string {
+	return `${result.shortSha} ${result.subject}`;
+}
+
+export function renderMerge(result: MergeResult): string {
+	if (result.status === "conflict") {
+		return `Merge conflict${result.conflicts?.length ? `: ${result.conflicts.join(", ")}` : ""}`;
+	}
+	return `Merge ${result.status}`;
+}
+
+export function renderRebase(result: RebaseResult): string {
+	if (result.status === "conflict") {
+		return `Rebase conflict${result.conflicts?.length ? `: ${result.conflicts.join(", ")}` : ""}`;
+	}
+	return `Rebase ${result.status}`;
+}
+
+export function renderCherryPick(result: CherryPickResult): string {
+	if (result.status === "conflict") {
+		return `Cherry-pick conflict${result.conflicts?.length ? `: ${result.conflicts.join(", ")}` : ""}`;
+	}
+	return `Cherry-pick applied ${result.appliedCommits?.length ?? 0} commits`;
+}
+
+export function renderFetch(result: FetchResult): string {
+	const lines = result.updated.map((entry) => `- ${entry.ref} ${entry.oldSha} -> ${entry.newSha}`);
+	if (result.pruned && result.pruned.length > 0) {
+		lines.push(`Pruned: ${result.pruned.join(", ")}`);
+	}
+	return lines.length > 0 ? lines.join("\n") : "Fetch completed";
+}
+
+export function renderPull(result: PullResult): string {
+	if (result.status === "conflict") {
+		return `Pull conflict${result.conflicts?.length ? `: ${result.conflicts.join(", ")}` : ""}`;
+	}
+	if (result.status === "up-to-date") return "Already up to date.";
+	return `Pulled ${result.commits ?? 0} commits`;
+}
+
+export function renderPush(result: PushResult): string {
+	return `Pushed ${result.commits} commits to ${result.remote}/${result.branch}`;
+}
+
+export function renderRelease(result: ReleaseResult): string {
+	if ("releases" in result) {
+		return `Releases: ${result.releases.length}`;
+	}
+	if ("tag" in result) {
+		return `Release ${result.tag}`;
+	}
+	return "Release operation completed";
+}
+
+export function renderTag(result: TagResult): string {
+	if ("tags" in result) {
+		return `Tags: ${result.tags.length}`;
+	}
+	return "Tag operation completed";
+}

package/src/safety/guards.ts

@@ -0,0 +1,144 @@
+import type { Operation, SafetyCheck, SafetyResult } from "../types";
+import { git } from "../utils";
+import { defaultPolicy, isProtectedBranch } from "./policies";
+
+const sessionCommits = new Set<string>();
+
+export function markCommitCreated(sha: string): void {
+	sessionCommits.add(sha);
+}
+
+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 getHeadSha(cwd?: string): Promise<string> {
+	const result = await git(["rev-parse", "HEAD"], { cwd });
+	if (result.error) return "";
+	return result.stdout.trim();
+}
+
+async function getBranchSync(cwd?: string): Promise<{ upstream: string | null; ahead: number; behind: number }> {
+	const result = await git(["status", "--porcelain=v2", "--branch", "--ahead-behind"], { cwd });
+	if (result.error) return { upstream: null, ahead: 0, behind: 0 };
+
+	let upstream: string | null = null;
+	let ahead = 0;
+	let behind = 0;
+	for (const line of result.stdout.split("\n")) {
+		if (line.startsWith("# branch.upstream ")) {
+			upstream = line.slice(18).trim();
+		}
+		if (line.startsWith("# branch.ab ")) {
+			const match = line.match(/\+(\d+) -?(\d+)/);
+			if (match) {
+				ahead = Number.parseInt(match[1], 10);
+				behind = Number.parseInt(match[2] ?? "0", 10);
+			}
+		}
+	}
+	return { upstream, ahead, behind };
+}
+
+async function isHeadPushed(cwd?: string): Promise<boolean> {
+	const sync = await getBranchSync(cwd);
+	if (!sync.upstream) return false;
+	return sync.ahead === 0;
+}
+
+function evaluateChecks(checks: SafetyCheck[]): SafetyResult {
+	const blocked = checks.find((check) => check.level === "block");
+	if (blocked) {
+		return {
+			blocked: true,
+			confirm: false,
+			message: blocked.message,
+			suggestion: blocked.suggestion,
+			override: blocked.override,
+			warnings: [],
+		};
+	}
+	const confirm = checks.find((check) => check.level === "confirm");
+	if (confirm) {
+		return {
+			blocked: false,
+			confirm: true,
+			message: confirm.message,
+			suggestion: confirm.suggestion,
+			override: confirm.override,
+			warnings: [],
+		};
+	}
+	const warnings = checks.filter((check) => check.level === "warn").map((check) => check.message);
+	return {
+		blocked: false,
+		confirm: false,
+		warnings,
+	};
+}
+
+export async function checkSafety(
+	operation: Operation,
+	params: Record<string, unknown>,
+	cwd?: string,
+): Promise<SafetyResult> {
+	const checks: SafetyCheck[] = [];
+
+	if (operation === "push" && params.force) {
+		const branch = (params.branch as string | undefined) ?? (await getCurrentBranch(cwd));
+		if (branch && isProtectedBranch(branch)) {
+			checks.push({
+				level: defaultPolicy.forcePushMain,
+				message: `Force push to protected branch '${branch}' is blocked`,
+				override: "force_override",
+			});
+		} else {
+			checks.push({
+				level: defaultPolicy.forcePush,
+				message: `Force push to '${branch || "current branch"}' will overwrite remote history`,
+				suggestion: "Consider using force_with_lease instead",
+			});
+		}
+	}
+
+	if (operation === "commit" && params.amend) {
+		const pushed = await isHeadPushed(cwd);
+		const headSha = await getHeadSha(cwd);
+		if (pushed && headSha && !sessionCommits.has(headSha)) {
+			checks.push({
+				level: defaultPolicy.amendPushed,
+				message: "Cannot amend: HEAD has been pushed to remote",
+				suggestion: "Create a new commit instead",
+			});
+		}
+	}
+
+	if (operation === "rebase") {
+		const pushed = await isHeadPushed(cwd);
+		if (pushed) {
+			checks.push({
+				level: defaultPolicy.rebasePushed,
+				message: "Cannot rebase: HEAD has been pushed to remote",
+				suggestion: "Merge instead of rebasing pushed commits",
+			});
+		}
+	}
+
+	if (operation === "restore" && params.worktree && !params.staged) {
+		checks.push({
+			level: defaultPolicy.discardChanges,
+			message: "Restoring worktree will discard local changes",
+		});
+	}
+
+	if (operation === "branch" && params.action === "delete") {
+		checks.push({
+			level: defaultPolicy.deleteBranch,
+			message: "Deleting a branch will remove its ref",
+		});
+	}
+
+	return evaluateChecks(checks);
+}

package/src/safety/policies.ts

@@ -0,0 +1,25 @@
+import type { SafetyPolicy } from "../types";
+
+export const defaultPolicy: SafetyPolicy = {
+	forcePush: "confirm",
+	forcePushMain: "block",
+	hardReset: "confirm",
+	discardChanges: "warn",
+	deleteBranch: "warn",
+	amendPushed: "block",
+	rebasePushed: "block",
+};
+
+export const defaultProtectedBranches = ["main", "master", "develop", "release/*"];
+
+export function isProtectedBranch(branch: string): boolean {
+	return defaultProtectedBranches.some((pattern) => {
+		if (pattern.endsWith("/")) {
+			return branch.startsWith(pattern);
+		}
+		if (pattern.endsWith("/*")) {
+			return branch.startsWith(pattern.slice(0, -1));
+		}
+		return branch === pattern;
+	});
+}