newpr 0.6.5 → 1.0.0

package/src/stack/partition.ts

@@ -0,0 +1,273 @@
+import type { FileGroup } from "../types/output.ts";
+import type { PrCommit } from "../types/github.ts";
+import type { LlmClient } from "../llm/client.ts";
+import type { PartitionResult, ReattributedFile, StackWarning } from "./types.ts";
+
+interface FileSummaryInput {
+	path: string;
+	status: string;
+	summary: string;
+}
+
+export interface PartitionInput {
+	groups: FileGroup[];
+	changed_files: string[];
+}
+
+export interface AmbiguityReport {
+	exclusive: Map<string, string>;
+	ambiguous: Array<{ path: string; groups: string[] }>;
+	unassigned: string[];
+}
+
+export function detectAmbiguousPaths(input: PartitionInput): AmbiguityReport {
+	const { groups, changed_files } = input;
+
+	const pathToGroups = new Map<string, string[]>();
+
+	for (const group of groups) {
+		for (const file of group.files) {
+			const existing = pathToGroups.get(file) ?? [];
+			existing.push(group.name);
+			pathToGroups.set(file, existing);
+		}
+	}
+
+	const exclusive = new Map<string, string>();
+	const ambiguous: Array<{ path: string; groups: string[] }> = [];
+	const unassigned: string[] = [];
+
+	for (const file of changed_files) {
+		const groups = pathToGroups.get(file);
+		if (!groups || groups.length === 0) {
+			unassigned.push(file);
+		} else if (groups.length === 1) {
+			exclusive.set(file, groups[0]!);
+		} else {
+			ambiguous.push({ path: file, groups });
+		}
+	}
+
+	return { exclusive, ambiguous, unassigned };
+}
+
+export function buildStackPartitionPrompt(
+	ambiguous: Array<{ path: string; groups: string[] }>,
+	unassigned: string[],
+	groups: FileGroup[],
+	fileSummaries: FileSummaryInput[],
+	commits: PrCommit[],
+): { system: string; user: string } {
+	const groupDescriptions = groups
+		.map((g) => `- "${g.name}" (${g.type}): ${g.description}`)
+		.join("\n");
+
+	const ambiguousSection = ambiguous.length > 0
+		? `\n\nAmbiguous files (appear in multiple groups):\n${ambiguous
+				.map((a) => `- ${a.path} → in groups: ${a.groups.join(", ")}`)
+				.join("\n")}`
+		: "";
+
+	const unassignedSection = unassigned.length > 0
+		? `\n\nUnassigned files (not in any group):\n${unassigned.map((f) => `- ${f}`).join("\n")}`
+		: "";
+
+	const fileSummarySection = fileSummaries.length > 0
+		? `\n\nFile summaries:\n${fileSummaries.map((f) => `- ${f.path}: ${f.summary}`).join("\n")}`
+		: "";
+
+	const commitSection = commits.length > 0
+		? `\n\nCommit history:\n${commits.map((c) => `- ${c.sha.substring(0, 7)} ${c.message}`).join("\n")}`
+		: "";
+
+	return {
+		system: `You are a code organization expert. Your task is to assign each file to EXACTLY ONE group for PR stacking.
+
+Rules:
+1. Each file must be assigned to exactly one group
+2. Do not change files that are already exclusively assigned
+3. For ambiguous files, choose the group where the file's changes are most relevant
+4. For unassigned files, assign them to the most appropriate existing group
+5. You may create a "Shared Foundation" group ONLY if files truly don't fit any existing group
+6. Respond ONLY with a JSON object
+
+Response format:
+{
+  "assignments": [
+    { "path": "file.ts", "group": "group-name", "reason": "brief reason" }
+  ],
+  "shared_foundation": null
+}
+
+If creating a Shared Foundation group:
+{
+  "assignments": [...],
+  "shared_foundation": { "name": "Shared Foundation", "description": "Common infrastructure changes", "files": [...] }
+}`,
+		user: `Groups:\n${groupDescriptions}${ambiguousSection}${unassignedSection}${fileSummarySection}${commitSection}\n\nAssign each ambiguous/unassigned file to exactly one group.`,
+	};
+}
+
+export async function partitionGroups(
+	client: LlmClient,
+	groups: FileGroup[],
+	changedFiles: string[],
+	fileSummaries: FileSummaryInput[],
+	commits: PrCommit[],
+): Promise<PartitionResult> {
+	const report = detectAmbiguousPaths({ groups, changed_files: changedFiles });
+
+	if (report.ambiguous.length === 0 && report.unassigned.length === 0) {
+		return {
+			ownership: report.exclusive,
+			reattributed: [],
+			warnings: [],
+			structured_warnings: [],
+		};
+	}
+
+	const prompt = buildStackPartitionPrompt(
+		report.ambiguous,
+		report.unassigned,
+		groups,
+		fileSummaries,
+		commits,
+	);
+
+	const response = await client.complete(prompt.system, prompt.user);
+	const parsed = parsePartitionResponse(response.content, report, groups);
+
+	return parsed;
+}
+
+function parsePartitionResponse(
+	raw: string,
+	report: AmbiguityReport,
+	groups: FileGroup[],
+): PartitionResult {
+	const jsonStr = extractJson(raw);
+	const parsed: unknown = JSON.parse(jsonStr);
+
+	if (!parsed || typeof parsed !== "object") {
+		throw new Error("Expected JSON object for partition response");
+	}
+
+	const data = parsed as Record<string, unknown>;
+	const assignments = data.assignments;
+
+	if (!Array.isArray(assignments)) {
+		throw new Error("Expected 'assignments' array in partition response");
+	}
+
+	const ownership = new Map(report.exclusive);
+	const reattributed: ReattributedFile[] = [];
+	const warnings: string[] = [];
+	const structuredWarnings: StackWarning[] = [];
+
+	const validGroupNames = new Set(groups.map((g) => g.name));
+
+	for (const item of assignments) {
+		const entry = item as Record<string, unknown>;
+		const path = String(entry.path ?? "");
+		const group = String(entry.group ?? "");
+		const reason = String(entry.reason ?? "");
+
+		if (!path || !group) {
+			warnings.push(`Invalid assignment entry: ${JSON.stringify(item)}`);
+			continue;
+		}
+
+		if (!validGroupNames.has(group)) {
+			warnings.push(`Unknown group "${group}" for file "${path}", skipping`);
+			structuredWarnings.push({
+				category: "system",
+				severity: "warn",
+				title: "Invalid group in AI response",
+				message: `"${path}" was assigned to unknown group "${group}" — skipped`,
+			});
+			continue;
+		}
+
+		const ambiguousEntry = report.ambiguous.find((a) => a.path === path);
+		const isUnassigned = report.unassigned.includes(path);
+
+		if (ambiguousEntry) {
+			reattributed.push({
+				path,
+				from_groups: ambiguousEntry.groups,
+				to_group: group,
+				reason,
+			});
+		} else if (isUnassigned) {
+			reattributed.push({
+				path,
+				from_groups: [],
+				to_group: group,
+				reason,
+			});
+		}
+
+		ownership.set(path, group);
+	}
+
+	const stillUnassigned = report.unassigned.filter((p) => !ownership.has(p));
+	const stillAmbiguous = report.ambiguous.filter((a) => !ownership.has(a.path));
+
+	const fallbackGroup = groups[groups.length - 1]?.name;
+
+	if (stillUnassigned.length > 0 && fallbackGroup) {
+		for (const path of stillUnassigned) {
+			ownership.set(path, fallbackGroup);
+			reattributed.push({ path, from_groups: [], to_group: fallbackGroup, reason: "LLM did not assign; fallback to last group" });
+		}
+		warnings.push(`Files force-assigned to "${fallbackGroup}" (LLM missed): ${stillUnassigned.join(", ")}`);
+		structuredWarnings.push({
+			category: "assignment",
+			severity: "warn",
+			title: `${stillUnassigned.length} file(s) auto-assigned to "${fallbackGroup}"`,
+			message: "AI did not assign these files — they were placed in the last group as fallback",
+			details: stillUnassigned,
+		});
+	}
+	if (stillAmbiguous.length > 0 && fallbackGroup) {
+		const paths = stillAmbiguous.map((a) => a.path);
+		for (const a of stillAmbiguous) {
+			ownership.set(a.path, fallbackGroup);
+			reattributed.push({ path: a.path, from_groups: a.groups, to_group: fallbackGroup, reason: "LLM did not resolve ambiguity; fallback to last group" });
+		}
+		warnings.push(`Files force-assigned to "${fallbackGroup}" (LLM missed): ${paths.join(", ")}`);
+		structuredWarnings.push({
+			category: "assignment",
+			severity: "warn",
+			title: `${paths.length} ambiguous file(s) auto-assigned to "${fallbackGroup}"`,
+			message: "AI did not resolve which group these files belong to — placed in last group",
+			details: paths,
+		});
+	}
+
+	let sharedFoundation: FileGroup | undefined;
+	if (data.shared_foundation && typeof data.shared_foundation === "object") {
+		const sf = data.shared_foundation as Record<string, unknown>;
+		sharedFoundation = {
+			name: String(sf.name ?? "Shared Foundation"),
+			type: "chore",
+			description: String(sf.description ?? "Common infrastructure changes"),
+			files: Array.isArray(sf.files) ? sf.files.map(String) : [],
+		};
+		validGroupNames.add(sharedFoundation.name);
+	}
+
+	return {
+		ownership,
+		reattributed,
+		shared_foundation_group: sharedFoundation,
+		warnings,
+		structured_warnings: structuredWarnings,
+	};
+}
+
+function extractJson(raw: string): string {
+	const codeBlockMatch = raw.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+	if (codeBlockMatch?.[1]) return codeBlockMatch[1].trim();
+	return raw.trim();
+}

package/src/stack/plan.test.ts

@@ -0,0 +1,154 @@
+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 { 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(), "plan-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();
+
+	writeFileSync(join(testRepoPath, "src", "auth.ts"), "export const auth = true;\nexport const token = 'abc';\n");
+	await Bun.$`git -C ${testRepoPath} add src/auth.ts`.quiet();
+	await Bun.$`git -C ${testRepoPath} commit -m "Update auth with token"`.quiet();
+
+	headSha = (await Bun.$`git -C ${testRepoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+});
+
+afterAll(() => {
+	if (testRepoPath) {
+		rmSync(testRepoPath, { recursive: true, force: true });
+	}
+});
+
+describe("createStackPlan", () => {
+	test("creates plan with expected trees for 2 groups", 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,
+		});
+
+		expect(plan.groups.length).toBe(2);
+		expect(plan.expected_trees.size).toBe(2);
+		expect(plan.expected_trees.get("Auth")).toBeDefined();
+		expect(plan.expected_trees.get("UI")).toBeDefined();
+
+		expect(plan.groups[0]?.id).toBe("Auth");
+		expect(plan.groups[0]?.files).toContain("src/auth.ts");
+		expect(plan.groups[1]?.id).toBe("UI");
+		expect(plan.groups[1]?.files).toContain("src/ui.tsx");
+	});
+
+	test("final tree matches HEAD tree (suffix propagation)", 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 headTreeResult = await Bun.$`git -C ${testRepoPath} rev-parse ${headSha}^{tree}`.quiet();
+		const headTree = headTreeResult.stdout.toString().trim();
+
+		const lastGroupId = "UI";
+		const lastExpectedTree = plan.expected_trees.get(lastGroupId);
+
+		expect(lastExpectedTree).toBe(headTree);
+	});
+
+	test("plan with file deletion", async () => {
+		const repoPath = mkdtempSync(join(tmpdir(), "plan-delete-test-"));
+		try {
+			await Bun.$`git init ${repoPath}`.quiet();
+			await Bun.$`git -C ${repoPath} config user.name "Test"`.quiet();
+			await Bun.$`git -C ${repoPath} config user.email "t@t.com"`.quiet();
+
+			writeFileSync(join(repoPath, "a.ts"), "a\n");
+			writeFileSync(join(repoPath, "b.ts"), "b\n");
+			await Bun.$`git -C ${repoPath} add -A`.quiet();
+			await Bun.$`git -C ${repoPath} commit -m "Init"`.quiet();
+			const base = (await Bun.$`git -C ${repoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+
+			await Bun.$`git -C ${repoPath} rm b.ts`.quiet();
+			await Bun.$`git -C ${repoPath} commit -m "Delete b.ts"`.quiet();
+			const head = (await Bun.$`git -C ${repoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+
+			const deltas = await extractDeltas(repoPath, base, head);
+			const ownership = new Map([["b.ts", "Cleanup"]]);
+			const groups: FileGroup[] = [
+				{ name: "Cleanup", type: "chore", description: "Remove unused", files: ["b.ts"] },
+			];
+
+			const plan = await createStackPlan({
+				repo_path: repoPath,
+				base_sha: base,
+				head_sha: head,
+				deltas,
+				ownership,
+				group_order: ["Cleanup"],
+				groups,
+			});
+
+			const headTree = (await Bun.$`git -C ${repoPath} rev-parse ${head}^{tree}`.quiet()).stdout.toString().trim();
+			expect(plan.expected_trees.get("Cleanup")).toBe(headTree);
+		} finally {
+			rmSync(repoPath, { recursive: true, force: true });
+		}
+	});
+});

package/src/stack/plan.ts

@@ -0,0 +1,139 @@
+import type {
+	DeltaEntry,
+	StackPlan,
+	StackGroup,
+} from "./types.ts";
+import type { FileGroup, GroupType } from "../types/output.ts";
+
+export interface PlanInput {
+	repo_path: string;
+	base_sha: string;
+	head_sha: string;
+	deltas: DeltaEntry[];
+	ownership: Map<string, string>;
+	group_order: string[];
+	groups: FileGroup[];
+}
+
+export async function createStackPlan(input: PlanInput): Promise<StackPlan> {
+	const { repo_path, base_sha, head_sha, deltas, ownership, group_order, groups } = input;
+
+	const groupRank = new Map<string, number>();
+	group_order.forEach((gid, idx) => groupRank.set(gid, idx));
+
+	const stackGroups = buildStackGroups(groups, group_order, ownership);
+
+	const tmpIndexFiles: string[] = [];
+	const expectedTrees = new Map<string, string>();
+
+	try {
+		for (let i = 0; i < group_order.length; i++) {
+			const idxFile = `/tmp/newpr-plan-idx-${Date.now()}-${i}-${Math.random().toString(36).slice(2, 8)}`;
+			tmpIndexFiles.push(idxFile);
+
+			const readTree = await Bun.$`GIT_INDEX_FILE=${idxFile} git -C ${repo_path} read-tree ${base_sha}`.quiet().nothrow();
+			if (readTree.exitCode !== 0) {
+				throw new Error(`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 < group_order.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 Error(`update-index failed for index ${idxNum}: ${updateIdx.stderr.toString().trim()}`);
+				}
+			}
+		}
+
+		for (let i = 0; i < group_order.length; i++) {
+			const idxFile = tmpIndexFiles[i];
+			const gid = group_order[i];
+			if (!idxFile || !gid) continue;
+
+			const writeTree = await Bun.$`GIT_INDEX_FILE=${idxFile} git -C ${repo_path} write-tree`.quiet().nothrow();
+			if (writeTree.exitCode !== 0) {
+				throw new Error(`write-tree failed for index ${i}: ${writeTree.stderr.toString().trim()}`);
+			}
+
+			expectedTrees.set(gid, writeTree.stdout.toString().trim());
+		}
+	} finally {
+		for (const idxFile of tmpIndexFiles) {
+			try {
+				await Bun.$`rm -f ${idxFile}`.quiet().nothrow();
+			} catch {}
+		}
+	}
+
+	return {
+		base_sha,
+		head_sha,
+		groups: stackGroups,
+		expected_trees: expectedTrees,
+	};
+}
+
+function buildStackGroups(
+	groups: FileGroup[],
+	groupOrder: string[],
+	ownership: Map<string, string>,
+): StackGroup[] {
+	const groupNameMap = new Map<string, FileGroup>();
+	for (const g of groups) {
+		groupNameMap.set(g.name, g);
+	}
+
+	return groupOrder.map((gid, idx) => {
+		const original = groupNameMap.get(gid);
+		const files: string[] = [];
+
+		for (const [path, owner] of ownership) {
+			if (owner === gid) files.push(path);
+		}
+
+		return {
+			id: gid,
+			name: original?.name ?? gid,
+			type: (original?.type ?? "chore") as GroupType,
+			description: original?.description ?? "",
+			files: files.sort(),
+			deps: original?.dependencies ?? [],
+			order: idx,
+		};
+	});
+}

package/src/stack/pr-title.ts

@@ -0,0 +1,64 @@
+import type { LlmClient } from "../llm/client.ts";
+import type { StackGroup } from "./types.ts";
+
+export async function generatePrTitles(
+	llmClient: LlmClient,
+	groups: StackGroup[],
+	prTitle: string,
+): Promise<Map<string, string>> {
+	const groupSummaries = groups
+		.map((g, i) => [
+			`Group ${i + 1}: "${g.name}"`,
+			`  Type: ${g.type}`,
+			`  Description: ${g.description}`,
+			`  Files (${g.files.length}): ${g.files.slice(0, 10).join(", ")}${g.files.length > 10 ? ` ... +${g.files.length - 10} more` : ""}`,
+		].join("\n"))
+		.join("\n\n");
+
+	const system = `You generate short PR titles for stacked PRs.
+
+Rules:
+- Format: "type: description" — NO scope parentheses
+- type: feat | fix | refactor | chore | docs | test | perf
+- description: 3-6 words, imperative mood, lowercase, no period
+- Be terse. Shorter is better. Omit filler words (add, implement, update, etc. when redundant)
+- Each title must be unique across the set
+
+Good: "feat: jwt token refresh", "fix: null user response", "refactor: shared validators", "chore: eslint config"
+Bad: "feat(auth): add jwt token refresh middleware for authentication module" (too long, has scope)
+
+Return ONLY JSON array: [{"group_id": "...", "title": "..."}]`;
+
+	const user = `Original PR: "${prTitle}"
+
+${groupSummaries}
+
+Generate a unique, descriptive PR title for each group. Return JSON array:
+[{"group_id": "...", "title": "..."}]`;
+
+	const response = await llmClient.complete(system, user);
+
+	const titles = new Map<string, string>();
+
+	try {
+		const cleaned = response.content.replace(/```(?:json)?\s*/g, "").replace(/```\s*/g, "").trim();
+		const parsed = JSON.parse(cleaned) as Array<{ group_id: string; title: string }>;
+		for (const item of parsed) {
+			if (item.group_id && item.title) {
+				titles.set(item.group_id, item.title);
+			}
+		}
+	} catch {
+		for (const g of groups) {
+			titles.set(g.id, `${g.type}: ${g.description}`);
+		}
+	}
+
+	for (const g of groups) {
+		if (!titles.has(g.id)) {
+			titles.set(g.id, `${g.type}: ${g.description}`);
+		}
+	}
+
+	return titles;
+}