newpr 0.6.5 → 1.0.0

package/src/stack/delta.ts

@@ -0,0 +1,264 @@
+import type { DeltaEntry, DeltaFileChange, DeltaStatus, StackGroupStats } from "./types.ts";
+
+export class DeltaExtractionError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "DeltaExtractionError";
+	}
+}
+
+export async function extractDeltas(
+	repoPath: string,
+	baseSha: string,
+	headSha: string,
+): Promise<DeltaEntry[]> {
+	const commitList = await getCommitList(repoPath, baseSha, headSha);
+	const deltas: DeltaEntry[] = [];
+
+	for (let i = 0; i < commitList.length; i++) {
+		const sha = commitList[i];
+		if (!sha) continue;
+
+		const parentSha = i === 0 ? baseSha : commitList[i - 1];
+		if (!parentSha) continue;
+
+		const changes = await extractCommitChanges(repoPath, parentSha, sha);
+		const metadata = await getCommitMetadata(repoPath, sha);
+
+		deltas.push({
+			sha,
+			parent_sha: parentSha,
+			author: metadata.author,
+			date: metadata.date,
+			message: metadata.message,
+			changes,
+		});
+	}
+
+	return deltas;
+}
+
+async function getCommitList(
+	repoPath: string,
+	baseSha: string,
+	headSha: string,
+): Promise<string[]> {
+	const result = await Bun.$`git -C ${repoPath} rev-list --first-parent --reverse ${baseSha}..${headSha}`
+		.quiet()
+		.nothrow();
+
+	if (result.exitCode !== 0) {
+		throw new DeltaExtractionError(
+			`Failed to get commit list: ${result.stderr.toString().trim()}`,
+		);
+	}
+
+	return result.stdout
+		.toString()
+		.trim()
+		.split("\n")
+		.filter((line) => line.length > 0);
+}
+
+async function getCommitMetadata(
+	repoPath: string,
+	sha: string,
+): Promise<{ author: string; date: string; message: string }> {
+	const result = await Bun.$`git -C ${repoPath} show -s --format=%an%n%aI%n%s ${sha}`
+		.quiet()
+		.nothrow();
+
+	if (result.exitCode !== 0) {
+		throw new DeltaExtractionError(
+			`Failed to get commit metadata: ${result.stderr.toString().trim()}`,
+		);
+	}
+
+	const lines = result.stdout.toString().trim().split("\n");
+	return {
+		author: lines[0] || "Unknown",
+		date: lines[1] || new Date().toISOString(),
+		message: lines[2] || "",
+	};
+}
+
+async function extractCommitChanges(
+	repoPath: string,
+	parentSha: string,
+	commitSha: string,
+): Promise<DeltaFileChange[]> {
+	const result = await Bun.$`git -C ${repoPath} diff-tree -r --raw -z -M --no-commit-id --no-textconv --no-ext-diff ${parentSha} ${commitSha}`
+		.quiet()
+		.nothrow();
+
+	if (result.exitCode !== 0) {
+		throw new DeltaExtractionError(
+			`Failed to extract changes: ${result.stderr.toString().trim()}`,
+		);
+	}
+
+	return parseDiffTreeOutput(result.stdout);
+}
+
+function parseDiffTreeOutput(output: Buffer): DeltaFileChange[] {
+	const changes: DeltaFileChange[] = [];
+	const entries = output.toString("utf-8").split("\0").filter((s) => s.length > 0);
+
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (!entry) continue;
+		if (!entry.startsWith(":")) continue;
+
+		const match = entry.match(
+			/^:(\d+) (\d+) ([0-9a-f]+) ([0-9a-f]+) ([AMDRC])(\d*)$/,
+		);
+
+		if (!match) continue;
+
+		const oldMode = match[1];
+		const newMode = match[2];
+		const oldBlob = match[3];
+		const newBlob = match[4];
+		const statusChar = match[5];
+		const pathInfo = entries[i + 1];
+
+		if (!oldMode || !newMode || !oldBlob || !newBlob || !statusChar || !pathInfo) {
+			continue;
+		}
+
+		const status = statusChar as DeltaStatus;
+		i++;
+
+		checkForUnsupportedModes(oldMode, newMode, pathInfo);
+
+		if (status === "R") {
+			const oldPath = pathInfo;
+			const newPath = entries[i + 1];
+			if (!newPath) continue;
+			i++;
+
+			changes.push({
+				status,
+				path: newPath,
+				old_path: oldPath,
+				old_blob: oldBlob,
+				new_blob: newBlob,
+				old_mode: oldMode,
+				new_mode: newMode,
+			});
+		} else {
+			changes.push({
+				status,
+				path: pathInfo,
+				old_blob: oldBlob,
+				new_blob: newBlob,
+				old_mode: oldMode,
+				new_mode: newMode,
+			});
+		}
+	}
+
+	return changes;
+}
+
+function checkForUnsupportedModes(
+	oldMode: string,
+	newMode: string,
+	path: string,
+): void {
+	const modes = [oldMode, newMode];
+
+	for (const mode of modes) {
+		if (mode === "160000") {
+			throw new DeltaExtractionError(
+				`Submodule detected at "${path}". Submodules are not supported in v1.`,
+			);
+		}
+
+		if (mode === "120000") {
+			throw new DeltaExtractionError(
+				`Symlink detected at "${path}". Symlinks are not supported in v1.`,
+			);
+		}
+	}
+}
+
+export async function computeGroupStats(
+	repoPath: string,
+	baseSha: string,
+	orderedGroupIds: string[],
+	expectedTrees: Map<string, string>,
+): Promise<Map<string, StackGroupStats>> {
+	const stats = new Map<string, StackGroupStats>();
+
+	for (let i = 0; i < orderedGroupIds.length; i++) {
+		const gid = orderedGroupIds[i]!;
+		const tree = expectedTrees.get(gid);
+		if (!tree) continue;
+
+		const prevTree = i === 0
+			? await resolveTree(repoPath, baseSha)
+			: expectedTrees.get(orderedGroupIds[i - 1]!);
+		if (!prevTree) continue;
+
+		const numstatResult = await Bun.$`git -C ${repoPath} diff-tree --numstat -r ${prevTree} ${tree}`.quiet().nothrow();
+		const rawResult = await Bun.$`git -C ${repoPath} diff-tree --raw --no-commit-id -r -z ${prevTree} ${tree}`.quiet().nothrow();
+
+		let additions = 0;
+		let deletions = 0;
+		let filesAdded = 0;
+		let filesModified = 0;
+		let filesDeleted = 0;
+
+		if (numstatResult.exitCode === 0) {
+			const lines = numstatResult.stdout.toString().trim().split("\n").filter(Boolean);
+			for (const line of lines) {
+				const parts = line.split("\t");
+				if (parts.length < 3) continue;
+				const [addStr, delStr] = parts;
+				if (addStr === "-" || delStr === "-") continue;
+				additions += parseInt(addStr!, 10);
+				deletions += parseInt(delStr!, 10);
+			}
+		}
+
+		if (rawResult.exitCode === 0) {
+			const entries = rawResult.stdout.toString("utf-8").split("\0").filter(Boolean);
+			for (const entry of entries) {
+				if (!entry.startsWith(":")) continue;
+				const match = entry.match(/^:\d+ \d+ [0-9a-f]+ [0-9a-f]+ ([AMDRC])/);
+				if (!match) continue;
+				const status = match[1];
+				if (status === "A") filesAdded++;
+				else if (status === "D") filesDeleted++;
+				else filesModified++;
+			}
+		}
+
+		stats.set(gid, { additions, deletions, files_added: filesAdded, files_modified: filesModified, files_deleted: filesDeleted });
+	}
+
+	return stats;
+}
+
+async function resolveTree(repoPath: string, commitSha: string): Promise<string> {
+	const result = await Bun.$`git -C ${repoPath} rev-parse ${commitSha}^{tree}`.quiet().nothrow();
+	if (result.exitCode !== 0) {
+		throw new DeltaExtractionError(`Failed to resolve tree for ${commitSha}: ${result.stderr.toString().trim()}`);
+	}
+	return result.stdout.toString().trim();
+}
+
+export function buildRenameMap(deltas: DeltaEntry[]): Map<string, string> {
+	const renameMap = new Map<string, string>();
+
+	for (const delta of deltas) {
+		for (const change of delta.changes) {
+			if (change.status === "R" && change.old_path) {
+				renameMap.set(change.old_path, change.path);
+			}
+		}
+	}
+
+	return renameMap;
+}

package/src/stack/execute.test.ts

@@ -0,0 +1,176 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createStackPlan } from "./plan.ts";
+import { executeStack } from "./execute.ts";
+import { extractDeltas } from "./delta.ts";
+import type { FileGroup } from "../types/output.ts";
+
+let testRepoPath: string;
+let baseSha: string;
+let headSha: string;
+
+beforeAll(async () => {
+	testRepoPath = mkdtempSync(join(tmpdir(), "exec-test-"));
+
+	await Bun.$`git init ${testRepoPath}`.quiet();
+	await Bun.$`git -C ${testRepoPath} config user.name "Test User"`.quiet();
+	await Bun.$`git -C ${testRepoPath} config user.email "test@example.com"`.quiet();
+
+	writeFileSync(join(testRepoPath, "README.md"), "initial\n");
+	await Bun.$`git -C ${testRepoPath} add README.md`.quiet();
+	await Bun.$`git -C ${testRepoPath} commit -m "Initial commit"`.quiet();
+
+	baseSha = (await Bun.$`git -C ${testRepoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+
+	mkdirSync(join(testRepoPath, "src"), { recursive: true });
+	writeFileSync(join(testRepoPath, "src", "auth.ts"), "export const auth = true;\n");
+	await Bun.$`git -C ${testRepoPath} add src/auth.ts`.quiet();
+	await Bun.$`git -C ${testRepoPath} commit -m "Add auth module"`.quiet();
+
+	writeFileSync(join(testRepoPath, "src", "ui.tsx"), "export const UI = () => <div/>;\n");
+	await Bun.$`git -C ${testRepoPath} add src/ui.tsx`.quiet();
+	await Bun.$`git -C ${testRepoPath} commit -m "Add UI component"`.quiet();
+
+	headSha = (await Bun.$`git -C ${testRepoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+});
+
+afterAll(() => {
+	if (testRepoPath) {
+		rmSync(testRepoPath, { recursive: true, force: true });
+	}
+});
+
+describe("executeStack", () => {
+	test("creates commit chain with correct parent links", async () => {
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+		const ownership = new Map([
+			["src/auth.ts", "Auth"],
+			["src/ui.tsx", "UI"],
+		]);
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth changes", files: ["src/auth.ts"] },
+			{ name: "UI", type: "feature", description: "UI changes", files: ["src/ui.tsx"] },
+		];
+
+		const plan = await createStackPlan({
+			repo_path: testRepoPath,
+			base_sha: baseSha,
+			head_sha: headSha,
+			deltas,
+			ownership,
+			group_order: ["Auth", "UI"],
+			groups,
+		});
+
+		const result = await executeStack({
+			repo_path: testRepoPath,
+			plan,
+			deltas,
+			ownership,
+			pr_author: { name: "Test Author", email: "author@test.com" },
+			pr_number: 42,
+			head_branch: "feature-branch",
+		});
+
+		expect(result.group_commits.length).toBe(2);
+		expect(result.source_copy_branch).toBe("newpr/stack-source/pr-42");
+
+		const copyRef = await Bun.$`git -C ${testRepoPath} rev-parse refs/heads/newpr/stack-source/pr-42`.quiet().nothrow();
+		expect(copyRef.exitCode).toBe(0);
+		expect(copyRef.stdout.toString().trim()).toBe(headSha);
+
+		const commit0 = result.group_commits[0];
+		const commit1 = result.group_commits[1];
+
+		expect(commit0?.group_id).toBe("Auth");
+		expect(commit1?.group_id).toBe("UI");
+
+		expect(commit0?.branch_name).toMatch(/^newpr-stack\/pr-42\/0-[a-z0-9]{6}$/);
+		expect(commit1?.branch_name).toMatch(/^newpr-stack\/pr-42\/1-[a-z0-9]{6}$/);
+
+		if (commit0) {
+			const parent0 = (await Bun.$`git -C ${testRepoPath} rev-parse ${commit0.commit_sha}^`.quiet()).stdout.toString().trim();
+			expect(parent0).toBe(baseSha);
+		}
+
+		if (commit0 && commit1) {
+			const parent1 = (await Bun.$`git -C ${testRepoPath} rev-parse ${commit1.commit_sha}^`.quiet()).stdout.toString().trim();
+			expect(parent1).toBe(commit0.commit_sha);
+		}
+	});
+
+	test("final tree equals HEAD tree", async () => {
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+		const ownership = new Map([
+			["src/auth.ts", "Auth"],
+			["src/ui.tsx", "UI"],
+		]);
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth", files: ["src/auth.ts"] },
+			{ name: "UI", type: "feature", description: "UI", files: ["src/ui.tsx"] },
+		];
+
+		const plan = await createStackPlan({
+			repo_path: testRepoPath,
+			base_sha: baseSha,
+			head_sha: headSha,
+			deltas,
+			ownership,
+			group_order: ["Auth", "UI"],
+			groups,
+		});
+
+		const result = await executeStack({
+			repo_path: testRepoPath,
+			plan,
+			deltas,
+			ownership,
+			pr_author: { name: "Test", email: "t@t.com" },
+			pr_number: 42,
+			head_branch: "feature-branch",
+		});
+
+		const headTree = (await Bun.$`git -C ${testRepoPath} rev-parse ${headSha}^{tree}`.quiet()).stdout.toString().trim();
+		expect(result.final_tree_sha).toBe(headTree);
+	});
+
+	test("branches are created in repo", async () => {
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+		const ownership = new Map([
+			["src/auth.ts", "Auth"],
+			["src/ui.tsx", "UI"],
+		]);
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth", files: ["src/auth.ts"] },
+			{ name: "UI", type: "feature", description: "UI", files: ["src/ui.tsx"] },
+		];
+
+		const plan = await createStackPlan({
+			repo_path: testRepoPath,
+			base_sha: baseSha,
+			head_sha: headSha,
+			deltas,
+			ownership,
+			group_order: ["Auth", "UI"],
+			groups,
+		});
+
+		const result = await executeStack({
+			repo_path: testRepoPath,
+			plan,
+			deltas,
+			ownership,
+			pr_author: { name: "Test", email: "t@t.com" },
+			pr_number: 99,
+			head_branch: "feature-branch",
+		});
+
+		for (const gc of result.group_commits) {
+			const ref = await Bun.$`git -C ${testRepoPath} rev-parse refs/heads/${gc.branch_name}`.quiet().nothrow();
+			expect(ref.exitCode).toBe(0);
+			expect(ref.stdout.toString().trim()).toBe(gc.commit_sha);
+		}
+	});
+});

package/src/stack/execute.ts

@@ -0,0 +1,194 @@
+import type {
+	DeltaEntry,
+	StackPlan,
+	StackExecResult,
+	GroupCommitInfo,
+} from "./types.ts";
+
+export class StackExecutionError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "StackExecutionError";
+	}
+}
+
+export interface ExecuteInput {
+	repo_path: string;
+	plan: StackPlan;
+	deltas: DeltaEntry[];
+	ownership: Map<string, string>;
+	pr_author: { name: string; email: string };
+	pr_number: number;
+	head_branch: string;
+}
+
+function generateAlphanumericId(length = 6): string {
+	const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+	let result = "";
+	for (let i = 0; i < length; i++) {
+		result += chars[Math.floor(Math.random() * chars.length)];
+	}
+	return result;
+}
+
+export async function executeStack(input: ExecuteInput): Promise<StackExecResult> {
+	const { repo_path, plan, deltas, ownership, pr_author, pr_number, head_branch: _head_branch } = input;
+
+	const runId = `newpr-stack-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+	const tmpIndexFiles: string[] = [];
+	const createdRefs: string[] = [];
+
+	const copyBranch = `newpr/stack-source/pr-${pr_number}`;
+	const copyRef = `refs/heads/${copyBranch}`;
+	const createCopy = await Bun.$`git -C ${repo_path} update-ref ${copyRef} ${plan.head_sha}`.quiet().nothrow();
+	if (createCopy.exitCode !== 0) {
+		throw new StackExecutionError(
+			`Failed to create source copy branch ${copyBranch}: ${createCopy.stderr.toString().trim()}`,
+		);
+	}
+	createdRefs.push(copyRef);
+
+	const groupOrder = plan.groups.map((g) => g.id);
+	const groupRank = new Map<string, number>();
+	groupOrder.forEach((gid, idx) => groupRank.set(gid, idx));
+
+	try {
+		for (let i = 0; i < groupOrder.length; i++) {
+			const idxFile = `/tmp/newpr-exec-idx-${runId}-${i}`;
+			tmpIndexFiles.push(idxFile);
+
+			const readTree = await Bun.$`GIT_INDEX_FILE=${idxFile} git -C ${repo_path} read-tree ${plan.base_sha}`.quiet().nothrow();
+			if (readTree.exitCode !== 0) {
+				throw new StackExecutionError(
+					`Failed to initialize index ${i}: ${readTree.stderr.toString().trim()}`,
+				);
+			}
+		}
+
+		for (const delta of deltas) {
+			const batchPerIndex = new Map<number, string[]>();
+
+			for (const change of delta.changes) {
+				const fileGroupId = ownership.get(change.path);
+				if (!fileGroupId) continue;
+
+				const fileRank = groupRank.get(fileGroupId);
+				if (fileRank === undefined) continue;
+
+				// Suffix propagation: update index[fileRank] through index[N-1]
+				for (let idxNum = fileRank; idxNum < groupOrder.length; idxNum++) {
+					let batch = batchPerIndex.get(idxNum);
+					if (!batch) {
+						batch = [];
+						batchPerIndex.set(idxNum, batch);
+					}
+
+					if (change.status === "D") {
+						batch.push(`0 ${"0".repeat(40)}\t${change.path}`);
+					} else if (change.status === "R") {
+						if (change.old_path) {
+							batch.push(`0 ${"0".repeat(40)}\t${change.old_path}`);
+						}
+						batch.push(`${change.new_mode} ${change.new_blob}\t${change.path}`);
+					} else {
+						batch.push(`${change.new_mode} ${change.new_blob}\t${change.path}`);
+					}
+				}
+			}
+
+			for (const [idxNum, lines] of batchPerIndex) {
+				const idxFile = tmpIndexFiles[idxNum];
+				if (!idxFile || lines.length === 0) continue;
+
+				const stdinData = lines.join("\n") + "\n";
+				const updateIdx = await Bun.$`echo ${stdinData} | GIT_INDEX_FILE=${idxFile} git -C ${repo_path} update-index --index-info`.quiet().nothrow();
+				if (updateIdx.exitCode !== 0) {
+					throw new StackExecutionError(
+						`update-index failed for index ${idxNum}: ${updateIdx.stderr.toString().trim()}`,
+					);
+				}
+			}
+		}
+
+		const groupCommits: GroupCommitInfo[] = [];
+		let prevCommitSha = plan.base_sha;
+
+		for (let i = 0; i < groupOrder.length; i++) {
+			const idxFile = tmpIndexFiles[i];
+			const gid = groupOrder[i];
+			const group = plan.groups[i];
+			if (!idxFile || !gid || !group) continue;
+
+			const writeTree = await Bun.$`GIT_INDEX_FILE=${idxFile} git -C ${repo_path} write-tree`.quiet().nothrow();
+			if (writeTree.exitCode !== 0) {
+				throw new StackExecutionError(
+					`write-tree failed for group ${gid}: ${writeTree.stderr.toString().trim()}`,
+				);
+			}
+			const treeSha = writeTree.stdout.toString().trim();
+
+			const expectedTree = plan.expected_trees.get(gid);
+			if (expectedTree && treeSha !== expectedTree) {
+				throw new StackExecutionError(
+					`Tree mismatch for group "${gid}": expected ${expectedTree}, got ${treeSha}`,
+				);
+			}
+
+			const commitMessage = group.pr_title ?? `${group.type}(${group.name}): ${group.description}`;
+
+			const commitTree = await Bun.$`git -C ${repo_path} commit-tree ${treeSha} -p ${prevCommitSha} -m ${commitMessage}`.env({
+				GIT_AUTHOR_NAME: pr_author.name,
+				GIT_AUTHOR_EMAIL: pr_author.email,
+				GIT_COMMITTER_NAME: pr_author.name,
+				GIT_COMMITTER_EMAIL: pr_author.email,
+			}).quiet().nothrow();
+
+			if (commitTree.exitCode !== 0) {
+				throw new StackExecutionError(
+					`commit-tree failed for group ${gid}: ${commitTree.stderr.toString().trim()}`,
+				);
+			}
+			const commitSha = commitTree.stdout.toString().trim();
+
+			const branchName = `newpr-stack/pr-${pr_number}/${group.order}-${generateAlphanumericId()}`;
+
+			const updateRef = await Bun.$`git -C ${repo_path} update-ref refs/heads/${branchName} ${commitSha}`.quiet().nothrow();
+			if (updateRef.exitCode !== 0) {
+				throw new StackExecutionError(
+					`update-ref failed for branch ${branchName}: ${updateRef.stderr.toString().trim()}`,
+				);
+			}
+			createdRefs.push(`refs/heads/${branchName}`);
+
+			groupCommits.push({
+				group_id: gid,
+				commit_sha: commitSha,
+				tree_sha: treeSha,
+				branch_name: branchName,
+				pr_title: group.pr_title,
+			});
+
+			prevCommitSha = commitSha;
+		}
+
+		const lastCommit = groupCommits[groupCommits.length - 1];
+		const finalTreeSha = lastCommit?.tree_sha ?? "";
+
+		return {
+			run_id: runId,
+			source_copy_branch: copyBranch,
+			group_commits: groupCommits,
+			final_tree_sha: finalTreeSha,
+			verified: false,
+		};
+	} catch (error) {
+		for (const ref of createdRefs) {
+			await Bun.$`git -C ${repo_path} update-ref -d ${ref}`.quiet().nothrow();
+		}
+		throw error;
+	} finally {
+		for (const idxFile of tmpIndexFiles) {
+			await Bun.$`rm -f ${idxFile}`.quiet().nothrow();
+		}
+	}
+}