newpr 1.0.23 → 1.0.25

package/package.json

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

package/src/stack/delta.test.ts

@@ -119,7 +119,7 @@ describe("extractDeltas", () => {
 });
 
 describe("computeGroupStats", () => {
-	test("uses merged dependency baseline for multi-parent DAG groups", async () => {
+	test("uses first dependency as baseline (matching publish base branch) for multi-parent DAG groups", async () => {
 		const repoPath = mkdtempSync(join(tmpdir(), "group-stats-dag-test-"));
 		try {
 			await Bun.$`git init ${repoPath}`.quiet();
@@ -180,14 +180,16 @@ describe("computeGroupStats", () => {
 			expect(stats.get("A")?.deletions).toBe(1);
 			expect(stats.get("B")?.additions).toBe(1);
 			expect(stats.get("B")?.deletions).toBe(1);
-			expect(stats.get("C")?.additions).toBe(1);
-			expect(stats.get("C")?.deletions).toBe(1);
+			expect(stats.get("C")?.additions).toBe(2);
+			expect(stats.get("C")?.deletions).toBe(2);
 			expect(detailed.get("A")?.file_stats["a.txt"]?.additions).toBe(1);
 			expect(detailed.get("A")?.file_stats["a.txt"]?.deletions).toBe(1);
 			expect(detailed.get("B")?.file_stats["b.txt"]?.additions).toBe(1);
 			expect(detailed.get("B")?.file_stats["b.txt"]?.deletions).toBe(1);
 			expect(detailed.get("C")?.file_stats["c.txt"]?.additions).toBe(1);
 			expect(detailed.get("C")?.file_stats["c.txt"]?.deletions).toBe(1);
+			expect(detailed.get("C")?.file_stats["b.txt"]?.additions).toBe(1);
+			expect(detailed.get("C")?.file_stats["b.txt"]?.deletions).toBe(1);
 		} finally {
 			rmSync(repoPath, { recursive: true, force: true });
 		}

package/src/stack/delta.ts

@@ -196,48 +196,7 @@ async function resolveParentTree(
 		return resolveTree(repoPath, baseSha);
 	}
 
-	if (parentIds.length === 1) {
-		return expectedTrees.get(parentIds[0]!) ?? resolveTree(repoPath, baseSha);
-	}
-
-	const parentTrees = parentIds.map((p) => expectedTrees.get(p)).filter((t): t is string => Boolean(t));
-	if (parentTrees.length === 0) return resolveTree(repoPath, baseSha);
-	if (parentTrees.length === 1) return parentTrees[0]!;
-
-	const syntheticCommitByTree = new Map<string, string>();
-	const ensureSyntheticCommit = async (treeSha: string): Promise<string | null> => {
-		const existing = syntheticCommitByTree.get(treeSha);
-		if (existing) return existing;
-
-		const result = await Bun.$`git -C ${repoPath} commit-tree ${treeSha} -p ${baseSha} -m "newpr synthetic parent"`.quiet().nothrow();
-		if (result.exitCode !== 0) return null;
-		const commitSha = result.stdout.toString().trim();
-		if (!commitSha) return null;
-		syntheticCommitByTree.set(treeSha, commitSha);
-		return commitSha;
-	};
-
-	let mergedTree = parentTrees[0]!;
-	let mergedCommit = await ensureSyntheticCommit(mergedTree);
-	if (!mergedCommit) return null;
-
-	for (let i = 1; i < parentTrees.length; i++) {
-		const nextCommit = await ensureSyntheticCommit(parentTrees[i]!);
-		if (!nextCommit) return null;
-
-		const mergeResult = await Bun.$`git -C ${repoPath} merge-tree --write-tree --allow-unrelated-histories ${mergedCommit} ${nextCommit}`.quiet().nothrow();
-		if (mergeResult.exitCode !== 0) return null;
-		const nextTree = mergeResult.stdout.toString().trim().split("\n")[0]?.trim();
-		if (!nextTree) return null;
-		mergedTree = nextTree;
-
-		const mergedCommitResult = await Bun.$`git -C ${repoPath} commit-tree ${mergedTree} -p ${mergedCommit} -p ${nextCommit} -m "newpr synthetic merged parent"`.quiet().nothrow();
-		if (mergedCommitResult.exitCode !== 0) return null;
-		mergedCommit = mergedCommitResult.stdout.toString().trim();
-		if (!mergedCommit) return null;
-	}
-
-	return mergedTree;
+	return expectedTrees.get(parentIds[0]!) ?? resolveTree(repoPath, baseSha);
 }
 
 export interface StackGroupComputedStats {

package/src/stack/feasibility.test.ts

@@ -181,4 +181,115 @@ describe("checkFeasibility", () => {
 		const order = result.ordered_group_ids!;
 		expect(order.indexOf("group-a")).toBeLessThan(order.indexOf("group-b"));
 	});
+
+	test("dependency edge wins over conflicting path-order edge", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "A", path: "ui.tsx" }]),
+			makeDelta("c2", "c1", [{ status: "A", path: "lib.ts" }]),
+		];
+
+		const ownership = new Map([
+			["ui.tsx", "ui-group"],
+			["lib.ts", "lib-group"],
+		]);
+
+		const declaredDeps = new Map([
+			["ui-group", ["lib-group"]],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
+
+		expect(result.feasible).toBe(true);
+		const order = result.ordered_group_ids!;
+		expect(order.indexOf("lib-group")).toBeLessThan(order.indexOf("ui-group"));
+		expect(result.dependency_edges).toBeDefined();
+		const depEdge = result.dependency_edges!.find(
+			(e) => e.from === "lib-group" && e.to === "ui-group",
+		);
+		expect(depEdge).toBeDefined();
+	});
+
+	test("dependency edge preserved when path-order creates opposing cycle", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [
+				{ status: "A", path: "ui.tsx" },
+				{ status: "A", path: "hook.ts" },
+			]),
+			makeDelta("c2", "c1", [{ status: "M", path: "ui.tsx" }]),
+		];
+
+		const ownership = new Map([
+			["ui.tsx", "ui-group"],
+			["hook.ts", "lib-group"],
+		]);
+
+		const declaredDeps = new Map([
+			["ui-group", ["lib-group"]],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
+
+		expect(result.feasible).toBe(true);
+		const order = result.ordered_group_ids!;
+		expect(order.indexOf("lib-group")).toBeLessThan(order.indexOf("ui-group"));
+	});
+
+	test("mutual dependency edges both survive when no path-order edges exist", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [
+				{ status: "A", path: "a.ts" },
+				{ status: "A", path: "b.ts" },
+			]),
+		];
+
+		const ownership = new Map([
+			["a.ts", "group-a"],
+			["b.ts", "group-b"],
+		]);
+
+		const declaredDeps = new Map([
+			["group-a", ["group-b"]],
+			["group-b", ["group-a"]],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
+
+		expect(result.feasible).toBe(true);
+		expect(result.ordered_group_ids).toHaveLength(2);
+	});
+
+	test("layer hint yields to import dep when they conflict", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [
+				{ status: "A", path: "api.ts" },
+				{ status: "A", path: "ui.tsx" },
+				{ status: "A", path: "types.ts" },
+			]),
+		];
+
+		const ownership = new Map([
+			["api.ts", "api-group"],
+			["ui.tsx", "ui-group"],
+			["types.ts", "types-group"],
+		]);
+
+		const declaredDeps = new Map([
+			["ui-group", ["api-group"]],
+		]);
+
+		const layerHints = new Map([
+			["api-group", ["ui-group"]],
+		]);
+
+		const result = checkFeasibility({
+			deltas,
+			ownership,
+			declared_deps: declaredDeps,
+			layer_hints: layerHints,
+		});
+
+		expect(result.feasible).toBe(true);
+		const order = result.ordered_group_ids!;
+		expect(order.indexOf("api-group")).toBeLessThan(order.indexOf("ui-group"));
+	});
 });

package/src/stack/feasibility.ts

@@ -9,10 +9,11 @@ interface FeasibilityInput {
 	deltas: DeltaEntry[];
 	ownership: Map<string, string>;
 	declared_deps?: Map<string, string[]>;
+	layer_hints?: Map<string, string[]>;
 }
 
 export function checkFeasibility(input: FeasibilityInput): FeasibilityResult {
-	const { deltas, ownership, declared_deps } = input;
+	const { deltas, ownership, declared_deps, layer_hints } = input;
 
 	const allGroups = new Set<string>(ownership.values());
 	if (allGroups.size <= 1) {
@@ -28,6 +29,9 @@ export function checkFeasibility(input: FeasibilityInput): FeasibilityResult {
 	if (declared_deps) {
 		addDeclaredDepEdges(declared_deps, allGroups, edges);
 	}
+	if (layer_hints) {
+		addLayerHintEdges(layer_hints, allGroups, edges);
+	}
 
 	const deduped = deduplicateEdges(edges);
 	const acyclic = breakAllCycles(deduped);
@@ -37,11 +41,22 @@ export function checkFeasibility(input: FeasibilityInput): FeasibilityResult {
 }
 
 function breakAllCycles(edges: ConstraintEdge[]): ConstraintEdge[] {
-	const edgeSet = new Set(edges.map((e) => `${e.from}→${e.to}`));
+	const edgeMap = new Map<string, ConstraintEdge>();
+	for (const e of edges) edgeMap.set(`${e.from}→${e.to}`, e);
+
 	const withoutMutual: ConstraintEdge[] = [];
 	for (const edge of edges) {
 		const reverseKey = `${edge.to}→${edge.from}`;
-		if (edgeSet.has(reverseKey) && edge.kind === "dependency") continue;
+		const reverse = edgeMap.get(reverseKey);
+		if (!reverse) {
+			// No mutual conflict — keep
+			withoutMutual.push(edge);
+			continue;
+		}
+		// Mutual conflict: drop the LESS important edge.
+		// dependency > path-order (dependency is build-critical)
+		if (edge.kind === "path-order" && reverse.kind === "dependency") continue;
+		// Same kind: keep both, let breakRemainingCycles handle it
 		withoutMutual.push(edge);
 	}
 	return breakRemainingCycles(withoutMutual);
@@ -77,7 +92,7 @@ function breakRemainingCycles(edges: ConstraintEdge[]): ConstraintEdge[] {
 
 	const prioritized = [...edges].sort((a, b) => {
 		const kindScore = (e: ConstraintEdge) =>
-			e.kind === "path-order" ? 0 : e.kind === "dependency" ? 1 : 2;
+			e.kind === "dependency" ? 0 : e.kind === "path-order" ? 1 : 2;
 		return kindScore(a) - kindScore(b);
 	});
 
@@ -174,6 +189,27 @@ function addDeclaredDepEdges(
 	}
 }
 
+function addLayerHintEdges(
+	layerHints: Map<string, string[]>,
+	allGroups: Set<string>,
+	edges: ConstraintEdge[],
+): void {
+	for (const [groupId, deps] of layerHints) {
+		if (!allGroups.has(groupId)) continue;
+
+		for (const depGroupId of deps) {
+			if (!allGroups.has(depGroupId)) continue;
+			if (groupId === depGroupId) continue;
+
+			edges.push({
+				from: depGroupId,
+				to: groupId,
+				kind: "path-order",
+			});
+		}
+	}
+}
+
 function deduplicateEdges(edges: ConstraintEdge[]): ConstraintEdge[] {
 	const seen = new Set<string>();
 	const result: ConstraintEdge[] = [];