newpr 0.6.5 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "0.6.5",
+  "version": "1.0.0",
   "description": "AI-powered large PR review tool - understand PRs with 1000+ lines of changes",
   "module": "src/cli/index.ts",
   "type": "module",

package/src/history/store.ts

@@ -221,6 +221,31 @@ export async function loadSlidesSidecar(
 	}
 }
 
+export async function saveStackSidecar(
+	id: string,
+	data: unknown,
+): Promise<void> {
+	ensureDirs();
+	const tmpPath = join(SESSIONS_DIR, `${id}.stack.json.tmp`);
+	const finalPath = join(SESSIONS_DIR, `${id}.stack.json`);
+	await Bun.write(tmpPath, JSON.stringify(data, null, 2));
+	const { renameSync } = await import("node:fs");
+	renameSync(tmpPath, finalPath);
+}
+
+export async function loadStackSidecar(
+	id: string,
+): Promise<Record<string, unknown> | null> {
+	try {
+		const filePath = join(SESSIONS_DIR, `${id}.stack.json`);
+		const file = Bun.file(filePath);
+		if (!(await file.exists())) return null;
+		return JSON.parse(await file.text()) as Record<string, unknown>;
+	} catch {
+		return null;
+	}
+}
+
 export function getHistoryPath(): string {
 	return HISTORY_DIR;
 }

package/src/stack/balance.ts

@@ -0,0 +1,128 @@
+import type { LlmClient } from "../llm/client.ts";
+import type { FileGroup } from "../types/output.ts";
+import type { StackWarning } from "./types.ts";
+
+export interface BalanceResult {
+	ownership: Map<string, string>;
+	warnings: StackWarning[];
+	moves: Array<{ path: string; from: string; to: string }>;
+}
+
+interface GroupSize {
+	id: string;
+	fileCount: number;
+}
+
+function detectImbalance(groups: GroupSize[]): { oversized: GroupSize[]; threshold: number } | null {
+	if (groups.length < 2) return null;
+
+	const counts = groups.map((g) => g.fileCount).sort((a, b) => a - b);
+	const median = counts[Math.floor(counts.length / 2)]!;
+	const threshold = Math.max(median * 3, 15);
+
+	const oversized = groups.filter((g) => g.fileCount > threshold);
+	if (oversized.length === 0) return null;
+
+	return { oversized, threshold };
+}
+
+export async function rebalanceGroups(
+	llmClient: LlmClient,
+	ownership: Map<string, string>,
+	groups: FileGroup[],
+): Promise<BalanceResult> {
+	const groupSizes = new Map<string, string[]>();
+	for (const [path, groupId] of ownership) {
+		const files = groupSizes.get(groupId) ?? [];
+		files.push(path);
+		groupSizes.set(groupId, files);
+	}
+
+	const sizeList: GroupSize[] = [...groupSizes.entries()].map(([id, files]) => ({
+		id,
+		fileCount: files.length,
+	}));
+
+	const imbalance = detectImbalance(sizeList);
+	if (!imbalance) {
+		return { ownership, warnings: [], moves: [] };
+	}
+
+	const groupDescriptions = groups
+		.map((g) => {
+			const files = groupSizes.get(g.name) ?? [];
+			return `- "${g.name}" (${g.type}, ${files.length} files): ${g.description}`;
+		})
+		.join("\n");
+
+	const oversizedDetails = imbalance.oversized
+		.map((g) => {
+			const files = groupSizes.get(g.id) ?? [];
+			return `"${g.id}" (${files.length} files):\n${files.map((f) => `  - ${f}`).join("\n")}`;
+		})
+		.join("\n\n");
+
+	const system = `You are a code organization expert. Your task is to rebalance PR groups so they are more evenly sized.
+
+Rules:
+1. Move files from oversized groups to other groups where they logically fit
+2. Only move files that genuinely belong better in another group based on file path and purpose
+3. If a file doesn't fit anywhere else, leave it in the current group
+4. Do NOT create new groups
+5. Aim for each group having roughly similar file counts
+6. Prioritize logical cohesion over perfect balance — don't force moves that don't make sense
+7. Move at most 50% of files from any oversized group
+
+Response format (JSON only, no markdown):
+{
+  "moves": [
+    { "path": "src/foo.ts", "to": "Target Group Name", "reason": "brief reason" }
+  ]
+}
+
+If no moves make sense, return: { "moves": [] }`;
+
+	const user = `Groups:\n${groupDescriptions}\n\nOversized groups (>${imbalance.threshold} files):\n${oversizedDetails}\n\nSuggest file moves to rebalance.`;
+
+	const newOwnership = new Map(ownership);
+	const moves: Array<{ path: string; from: string; to: string }> = [];
+	const warnings: StackWarning[] = [];
+
+	try {
+		const response = await llmClient.complete(system, user);
+		const cleaned = response.content.replace(/```(?:json)?\s*/g, "").replace(/```\s*/g, "").trim();
+		const parsed = JSON.parse(cleaned) as { moves: Array<{ path: string; to: string; reason: string }> };
+
+		const validGroupNames = new Set(groups.map((g) => g.name));
+
+		for (const move of parsed.moves ?? []) {
+			if (!move.path || !move.to) continue;
+			if (!validGroupNames.has(move.to)) continue;
+
+			const currentGroup = newOwnership.get(move.path);
+			if (!currentGroup || currentGroup === move.to) continue;
+
+			newOwnership.set(move.path, move.to);
+			moves.push({ path: move.path, from: currentGroup, to: move.to });
+		}
+
+		if (moves.length > 0) {
+			warnings.push({
+				category: "grouping",
+				severity: "info",
+				title: `${moves.length} file(s) rebalanced across groups`,
+				message: "Files were moved from oversized groups to better-fitting groups for more balanced PRs",
+				details: moves.map((m) => `${m.path}: "${m.from}" → "${m.to}"`),
+			});
+		}
+	} catch {
+		warnings.push({
+			category: "system",
+			severity: "warn",
+			title: "Group rebalancing skipped",
+			message: "AI rebalancing failed — proceeding with original distribution",
+		});
+	}
+
+	return { ownership: newOwnership, warnings, moves };
+}

package/src/stack/coupling.test.ts

@@ -0,0 +1,158 @@
+import { describe, test, expect } from "bun:test";
+import { applyCouplingRules } from "./coupling.ts";
+
+describe("applyCouplingRules", () => {
+	test("package.json + bun.lockb in different groups → forced to same group", () => {
+		const ownership = new Map([
+			["package.json", "group-a"],
+			["bun.lockb", "group-b"],
+			["src/index.ts", "group-a"],
+		]);
+		const changedFiles = ["package.json", "bun.lockb", "src/index.ts"];
+		const groupOrder = ["group-a", "group-b"];
+
+		const result = applyCouplingRules(ownership, changedFiles, groupOrder);
+
+		// Both should be in group-a (earliest)
+		expect(result.ownership.get("package.json")).toBe("group-a");
+		expect(result.ownership.get("bun.lockb")).toBe("group-a");
+		expect(result.ownership.get("src/index.ts")).toBe("group-a");
+
+		// Should have warning
+		expect(result.warnings.length).toBeGreaterThan(0);
+		expect(result.warnings[0]).toContain("package.json");
+		expect(result.warnings[0]).toContain("bun.lockb");
+
+		// Should have forced merge
+		expect(result.forced_merges).toEqual([
+			{
+				path: "bun.lockb",
+				from_group: "group-b",
+				to_group: "group-a",
+			},
+		]);
+	});
+
+	test("coupling set in same group → no change", () => {
+		const ownership = new Map([
+			["package.json", "group-a"],
+			["bun.lockb", "group-a"],
+			["src/index.ts", "group-b"],
+		]);
+		const changedFiles = ["package.json", "bun.lockb", "src/index.ts"];
+		const groupOrder = ["group-a", "group-b"];
+
+		const result = applyCouplingRules(ownership, changedFiles, groupOrder);
+
+		// No changes
+		expect(result.ownership.get("package.json")).toBe("group-a");
+		expect(result.ownership.get("bun.lockb")).toBe("group-a");
+		expect(result.ownership.get("src/index.ts")).toBe("group-b");
+
+		// No warnings
+		expect(result.warnings).toEqual([]);
+		expect(result.forced_merges).toEqual([]);
+	});
+
+	test("no coupling files → no change", () => {
+		const ownership = new Map([
+			["src/index.ts", "group-a"],
+			["src/utils.ts", "group-b"],
+		]);
+		const changedFiles = ["src/index.ts", "src/utils.ts"];
+		const groupOrder = ["group-a", "group-b"];
+
+		const result = applyCouplingRules(ownership, changedFiles, groupOrder);
+
+		// No changes
+		expect(result.ownership.get("src/index.ts")).toBe("group-a");
+		expect(result.ownership.get("src/utils.ts")).toBe("group-b");
+
+		// No warnings
+		expect(result.warnings).toEqual([]);
+		expect(result.forced_merges).toEqual([]);
+	});
+
+	test("tsconfig.json + tsconfig.base.json → coupled", () => {
+		const ownership = new Map([
+			["tsconfig.json", "group-a"],
+			["tsconfig.base.json", "group-b"],
+			["src/index.ts", "group-a"],
+		]);
+		const changedFiles = ["tsconfig.json", "tsconfig.base.json", "src/index.ts"];
+		const groupOrder = ["group-a", "group-b"];
+
+		const result = applyCouplingRules(ownership, changedFiles, groupOrder);
+
+		// Both tsconfig files should be in group-a
+		expect(result.ownership.get("tsconfig.json")).toBe("group-a");
+		expect(result.ownership.get("tsconfig.base.json")).toBe("group-a");
+
+		// Should have warning
+		expect(result.warnings.length).toBeGreaterThan(0);
+		expect(result.warnings[0]).toContain("tsconfig");
+
+		// Should have forced merge
+		expect(result.forced_merges).toEqual([
+			{
+				path: "tsconfig.base.json",
+				from_group: "group-b",
+				to_group: "group-a",
+			},
+		]);
+	});
+
+	test(".gitattributes always in earliest group", () => {
+		const ownership = new Map([
+			[".gitattributes", "group-b"],
+			["src/index.ts", "group-a"],
+		]);
+		const changedFiles = [".gitattributes", "src/index.ts"];
+		const groupOrder = ["group-a", "group-b"];
+
+		const result = applyCouplingRules(ownership, changedFiles, groupOrder);
+
+		// .gitattributes should be in group-a (earliest)
+		expect(result.ownership.get(".gitattributes")).toBe("group-b");
+		// Note: .gitattributes is in its own coupling set, so it won't move
+		// unless there are other files in the same set
+	});
+
+	test("multiple lockfiles in different groups → all forced to earliest", () => {
+		const ownership = new Map([
+			["package.json", "group-a"],
+			["bun.lockb", "group-b"],
+			["yarn.lock", "group-c"],
+		]);
+		const changedFiles = ["package.json", "bun.lockb", "yarn.lock"];
+		const groupOrder = ["group-a", "group-b", "group-c"];
+
+		const result = applyCouplingRules(ownership, changedFiles, groupOrder);
+
+		// All should be in group-a
+		expect(result.ownership.get("package.json")).toBe("group-a");
+		expect(result.ownership.get("bun.lockb")).toBe("group-a");
+		expect(result.ownership.get("yarn.lock")).toBe("group-a");
+
+		// Should have 2 forced merges
+		expect(result.forced_merges.length).toBe(2);
+	});
+
+	test("does not mutate input ownership map", () => {
+		const ownership = new Map([
+			["package.json", "group-a"],
+			["bun.lockb", "group-b"],
+		]);
+		const originalSize = ownership.size;
+		const originalPackageGroup = ownership.get("package.json");
+
+		applyCouplingRules(ownership, ["package.json", "bun.lockb"], [
+			"group-a",
+			"group-b",
+		]);
+
+		// Original map unchanged
+		expect(ownership.size).toBe(originalSize);
+		expect(ownership.get("package.json")).toBe(originalPackageGroup);
+	});
+});

package/src/stack/coupling.ts

@@ -0,0 +1,135 @@
+import type { StackWarning } from "./types.ts";
+
+export interface ForcedMerge {
+	path: string;
+	from_group: string;
+	to_group: string;
+}
+
+export interface CouplingResult {
+	ownership: Map<string, string>;
+	warnings: string[];
+	structured_warnings: StackWarning[];
+	forced_merges: ForcedMerge[];
+}
+
+/**
+ * Hardcoded atomic coupling sets for v1.
+ * Files in the same set MUST be in the same group.
+ */
+const COUPLING_SETS: Array<Set<string> | ((path: string) => boolean)> = [
+	// Lockfiles + package.json
+	new Set([
+		"package.json",
+		"bun.lockb",
+		"package-lock.json",
+		"yarn.lock",
+		"pnpm-lock.yaml",
+	]),
+
+	// .gitattributes (always earliest group)
+	new Set([".gitattributes"]),
+
+	// tsconfig family (glob pattern)
+	(path: string) => path === "tsconfig.json" || /^tsconfig\..*\.json$/.test(path),
+];
+
+/**
+ * Apply coupling rules to ownership map.
+ *
+ * When files in a coupling set span multiple groups:
+ * - Move all to the earliest group (by groupOrder)
+ * - Return warnings + forcedMerges
+ *
+ * @param ownership - Current path -> groupId mapping
+ * @param changedFiles - All changed file paths
+ * @param groupOrder - Ordered list of group IDs (earliest first)
+ * @returns Modified ownership + warnings + forced merges
+ */
+export function applyCouplingRules(
+	ownership: Map<string, string>,
+	changedFiles: string[],
+	groupOrder: string[],
+): CouplingResult {
+	const newOwnership = new Map(ownership);
+	const warnings: string[] = [];
+	const structuredWarnings: StackWarning[] = [];
+	const forcedMerges: ForcedMerge[] = [];
+
+	// Build group rank map for ordering
+	const groupRank = new Map<string, number>();
+	groupOrder.forEach((groupId, idx) => groupRank.set(groupId, idx));
+
+	// Process each coupling set
+	for (const couplingSet of COUPLING_SETS) {
+		const matchedFiles: string[] = [];
+
+		// Find all changed files in this coupling set
+		for (const file of changedFiles) {
+			const matches =
+				couplingSet instanceof Set
+					? couplingSet.has(file)
+					: couplingSet(file);
+
+			if (matches) {
+				matchedFiles.push(file);
+			}
+		}
+
+		if (matchedFiles.length === 0) continue;
+
+		// Collect groups these files belong to
+		const groups = new Set<string>();
+		for (const file of matchedFiles) {
+			const group = newOwnership.get(file);
+			if (group) groups.add(group);
+		}
+
+		// If all in same group, no action needed
+		if (groups.size <= 1) continue;
+
+		// Find earliest group
+		const sortedGroups = Array.from(groups).sort(
+			(a, b) => (groupRank.get(a) ?? Infinity) - (groupRank.get(b) ?? Infinity),
+		);
+		const targetGroup = sortedGroups[0];
+		if (!targetGroup) continue;
+
+		// Move all files to earliest group
+		for (const file of matchedFiles) {
+			const currentGroup = newOwnership.get(file);
+			if (currentGroup && currentGroup !== targetGroup) {
+				newOwnership.set(file, targetGroup);
+				forcedMerges.push({
+					path: file,
+					from_group: currentGroup,
+					to_group: targetGroup,
+				});
+			} else if (!currentGroup) {
+				// File not in ownership map, assign to target group
+				newOwnership.set(file, targetGroup);
+			}
+		}
+
+		// Add warning
+		const fileList = matchedFiles.join(", ");
+		const groupList = Array.from(groups).join(", ");
+		warnings.push(
+			`Coupling constraint: [${fileList}] were in groups [${groupList}], forced to earliest group "${targetGroup}"`,
+		);
+		structuredWarnings.push({
+			category: "coupling",
+			severity: "info",
+			title: `${forcedMerges.length} file(s) moved to "${targetGroup}" by coupling rule`,
+			message: `Files [${fileList}] must stay together — moved from [${groupList}] to earliest group`,
+			details: matchedFiles,
+		});
+	}
+
+	return {
+		ownership: newOwnership,
+		warnings,
+		structured_warnings: structuredWarnings,
+		forced_merges: forcedMerges,
+	};
+}

package/src/stack/delta.test.ts

@@ -0,0 +1,223 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { extractDeltas, buildRenameMap } from "./delta.ts";
+
+let testRepoPath: string;
+
+beforeAll(async () => {
+	testRepoPath = mkdtempSync(join(tmpdir(), "delta-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();
+
+	await Bun.$`echo "initial" > ${join(testRepoPath, "README.md")}`.quiet();
+	await Bun.$`git -C ${testRepoPath} add README.md`.quiet();
+	await Bun.$`git -C ${testRepoPath} commit -m "Initial commit"`.quiet();
+});
+
+afterAll(() => {
+	if (testRepoPath) {
+		rmSync(testRepoPath, { recursive: true, force: true });
+	}
+});
+
+describe("extractDeltas", () => {
+	test("extracts A/M/D status correctly", async () => {
+		const baseSha = await getCurrentSha(testRepoPath);
+
+		await Bun.$`echo "new file" > ${join(testRepoPath, "new.txt")}`.quiet();
+		await Bun.$`git -C ${testRepoPath} add new.txt`.quiet();
+		await Bun.$`git -C ${testRepoPath} commit -m "Add new.txt"`.quiet();
+
+		await Bun.$`echo "modified" > ${join(testRepoPath, "README.md")}`.quiet();
+		await Bun.$`git -C ${testRepoPath} add README.md`.quiet();
+		await Bun.$`git -C ${testRepoPath} commit -m "Modify README"`.quiet();
+
+		await Bun.$`git -C ${testRepoPath} rm new.txt`.quiet();
+		await Bun.$`git -C ${testRepoPath} commit -m "Delete new.txt"`.quiet();
+
+		const headSha = await getCurrentSha(testRepoPath);
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+
+		expect(deltas.length).toBe(3);
+
+		const hasAdd = deltas.some((d) => d.changes.some((c) => c.status === "A" && c.path === "new.txt"));
+		expect(hasAdd).toBe(true);
+
+		const hasModify = deltas.some((d) => d.changes.some((c) => c.status === "M" && c.path === "README.md"));
+		expect(hasModify).toBe(true);
+
+		const hasDelete = deltas.some((d) => d.changes.some((c) => c.status === "D" && c.path === "new.txt"));
+		expect(hasDelete).toBe(true);
+	});
+
+	test("extracts rename (R status) correctly", async () => {
+		const baseSha = await getCurrentSha(testRepoPath);
+
+		await Bun.$`echo "content" > ${join(testRepoPath, "old-name.txt")}`.quiet();
+		await Bun.$`git -C ${testRepoPath} add old-name.txt`.quiet();
+		await Bun.$`git -C ${testRepoPath} commit -m "Add old-name.txt"`.quiet();
+
+		await Bun.$`git -C ${testRepoPath} mv old-name.txt new-name.txt`.quiet();
+		await Bun.$`git -C ${testRepoPath} commit -m "Rename file"`.quiet();
+
+		const headSha = await getCurrentSha(testRepoPath);
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+
+		const allRenames = deltas.flatMap((d) => d.changes.filter((c) => c.status === "R"));
+		const renameChange = allRenames.find((c) => c.old_path === "old-name.txt");
+
+		expect(renameChange).toBeDefined();
+		expect(renameChange?.old_path).toBe("old-name.txt");
+		expect(renameChange?.path).toBe("new-name.txt");
+	});
+
+	test("handles merge commits via first-parent linearization", async () => {
+		const baseSha = await getCurrentSha(testRepoPath);
+
+		await Bun.$`git -C ${testRepoPath} checkout -b feature`.quiet();
+		await Bun.$`echo "feature" > ${join(testRepoPath, "feature.txt")}`.quiet();
+		await Bun.$`git -C ${testRepoPath} add feature.txt`.quiet();
+		await Bun.$`git -C ${testRepoPath} commit -m "Feature commit"`.quiet();
+
+		await Bun.$`git -C ${testRepoPath} checkout main`.quiet();
+		await Bun.$`echo "main" > ${join(testRepoPath, "main.txt")}`.quiet();
+		await Bun.$`git -C ${testRepoPath} add main.txt`.quiet();
+		await Bun.$`git -C ${testRepoPath} commit -m "Main commit"`.quiet();
+
+		await Bun.$`git -C ${testRepoPath} merge feature --no-edit`.quiet();
+
+		const headSha = await getCurrentSha(testRepoPath);
+
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+		expect(deltas.length).toBeGreaterThanOrEqual(2);
+		const allPaths = deltas.flatMap((d) => d.changes.map((c) => c.path));
+		expect(allPaths).toContain("main.txt");
+		expect(allPaths).toContain("feature.txt");
+	});
+
+	test("includes commit metadata (author, date, message)", async () => {
+		const baseSha = await getCurrentSha(testRepoPath);
+
+		await Bun.$`echo "test" > ${join(testRepoPath, "test.txt")}`.quiet();
+		await Bun.$`git -C ${testRepoPath} add test.txt`.quiet();
+		await Bun.$`git -C ${testRepoPath} commit -m "Test commit message"`.quiet();
+
+		const headSha = await getCurrentSha(testRepoPath);
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+
+		expect(deltas.length).toBe(1);
+		expect(deltas[0]?.author).toBe("Test User");
+		expect(deltas[0]?.message).toBe("Test commit message");
+		expect(deltas[0]?.date).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+	});
+});
+
+describe("buildRenameMap", () => {
+	test("builds rename map from deltas", () => {
+		const deltas = [
+			{
+				sha: "abc123",
+				parent_sha: "def456",
+				author: "Test",
+				date: "2024-01-01",
+				message: "Rename",
+				changes: [
+					{
+						status: "R" as const,
+						path: "new.txt",
+						old_path: "old.txt",
+						old_blob: "blob1",
+						new_blob: "blob2",
+						old_mode: "100644",
+						new_mode: "100644",
+					},
+				],
+			},
+		];
+
+		const renameMap = buildRenameMap(deltas);
+
+		expect(renameMap.get("old.txt")).toBe("new.txt");
+	});
+
+	test("handles multiple renames", () => {
+		const deltas = [
+			{
+				sha: "abc123",
+				parent_sha: "def456",
+				author: "Test",
+				date: "2024-01-01",
+				message: "Rename 1",
+				changes: [
+					{
+						status: "R" as const,
+						path: "b.txt",
+						old_path: "a.txt",
+						old_blob: "blob1",
+						new_blob: "blob2",
+						old_mode: "100644",
+						new_mode: "100644",
+					},
+				],
+			},
+			{
+				sha: "ghi789",
+				parent_sha: "abc123",
+				author: "Test",
+				date: "2024-01-02",
+				message: "Rename 2",
+				changes: [
+					{
+						status: "R" as const,
+						path: "c.txt",
+						old_path: "b.txt",
+						old_blob: "blob2",
+						new_blob: "blob3",
+						old_mode: "100644",
+						new_mode: "100644",
+					},
+				],
+			},
+		];
+
+		const renameMap = buildRenameMap(deltas);
+
+		expect(renameMap.get("a.txt")).toBe("b.txt");
+		expect(renameMap.get("b.txt")).toBe("c.txt");
+	});
+
+	test("returns empty map for no renames", () => {
+		const deltas = [
+			{
+				sha: "abc123",
+				parent_sha: "def456",
+				author: "Test",
+				date: "2024-01-01",
+				message: "Add file",
+				changes: [
+					{
+						status: "A" as const,
+						path: "new.txt",
+						old_blob: "0000000000000000000000000000000000000000",
+						new_blob: "blob1",
+						old_mode: "000000",
+						new_mode: "100644",
+					},
+				],
+			},
+		];
+
+		const renameMap = buildRenameMap(deltas);
+
+		expect(renameMap.size).toBe(0);
+	});
+});
+
+async function getCurrentSha(repoPath: string): Promise<string> {
+	const result = await Bun.$`git -C ${repoPath} rev-parse HEAD`.quiet();
+	return result.stdout.toString().trim();
+}