newpr 1.0.22 → 1.0.23

package/src/stack/plan.test.ts

@@ -80,6 +80,35 @@ describe("createStackPlan", () => {
 		expect(plan.groups[1]?.files).toContain("src/ui.tsx");
 	});
 
+	test("ignores self dependency edges when building group deps", 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,
+			dependency_edges: [{ from: "UI", to: "UI" }],
+		});
+
+		const uiGroup = plan.groups.find((g) => g.id === "UI");
+		expect(uiGroup).toBeDefined();
+		expect(uiGroup?.deps).toEqual([]);
+	});
+
 	test("final tree matches HEAD tree (suffix propagation)", async () => {
 		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
 
@@ -101,6 +130,7 @@ describe("createStackPlan", () => {
 			ownership,
 			group_order: ["Auth", "UI"],
 			groups,
+			dependency_edges: [{ from: "Auth", to: "UI" }],
 		});
 
 		const headTreeResult = await Bun.$`git -C ${testRepoPath} rev-parse ${headSha}^{tree}`.quiet();

package/src/stack/plan.ts

@@ -22,10 +22,12 @@ export async function createStackPlan(input: PlanInput): Promise<StackPlan> {
 	const groupRank = new Map<string, number>();
 	group_order.forEach((gid, idx) => groupRank.set(gid, idx));
 
-	const dagParents = buildDagParents(group_order, dependency_edges ?? []);
+	const edges = dependency_edges ?? [];
+	const dagParents = buildDagParents(group_order, edges);
+	const explicitDagParents = buildExplicitDagParents(group_order, edges);
 	const ancestorSets = buildAncestorSets(group_order, dagParents);
 
-	const stackGroups = buildStackGroups(groups, group_order, ownership, dagParents);
+	const stackGroups = buildStackGroups(groups, group_order, ownership, dagParents, explicitDagParents);
 
 	const tmpIndexFiles: string[] = [];
 	const expectedTrees = new Map<string, string>();
@@ -108,39 +110,41 @@ export async function createStackPlan(input: PlanInput): Promise<StackPlan> {
 		}
 	}
 
+	const ancestorSetsRecord = new Map<string, string[]>();
+	for (const [gid, set] of ancestorSets) {
+		ancestorSetsRecord.set(gid, Array.from(set));
+	}
+
 	return {
 		base_sha,
 		head_sha,
 		groups: stackGroups,
 		expected_trees: expectedTrees,
+		ancestor_sets: ancestorSetsRecord,
 	};
 }
 
 export function buildDagParents(
 	groupOrder: string[],
 	dependencyEdges: Array<{ from: string; to: string }>,
+): Map<string, string[]> {
+	return buildExplicitDagParents(groupOrder, dependencyEdges);
+}
+
+export function buildExplicitDagParents(
+	groupOrder: string[],
+	dependencyEdges: Array<{ from: string; to: string }>,
 ): Map<string, string[]> {
 	const parents = new Map<string, string[]>();
 	for (const gid of groupOrder) parents.set(gid, []);
 
 	for (const edge of dependencyEdges) {
 		if (!parents.has(edge.to)) continue;
+		if (edge.from === edge.to) continue;
 		const arr = parents.get(edge.to)!;
 		if (!arr.includes(edge.from)) arr.push(edge.from);
 	}
 
-	for (const gid of groupOrder) {
-		if ((parents.get(gid) ?? []).length === 0) {
-			const rank = groupOrder.indexOf(gid);
-			if (rank > 0) {
-				const prev = groupOrder[rank - 1]!;
-				if (!dependencyEdges.some((e) => e.to === gid)) {
-					parents.set(gid, [prev]);
-				}
-			}
-		}
-	}
-
 	return parents;
 }
 
@@ -170,6 +174,7 @@ function buildStackGroups(
 	groupOrder: string[],
 	ownership: Map<string, string>,
 	dagParents: Map<string, string[]>,
+	explicitDagParents: Map<string, string[]>,
 ): StackGroup[] {
 	const groupNameMap = new Map<string, FileGroup>();
 	for (const g of groups) {
@@ -191,6 +196,7 @@ function buildStackGroups(
 			description: original?.description ?? "",
 			files: files.sort(),
 			deps: dagParents.get(gid) ?? [],
+			explicit_deps: explicitDagParents.get(gid) ?? [],
 			order: idx,
 		};
 	});

package/src/stack/publish.test.ts

@@ -0,0 +1,83 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { PrMeta } from "../types/output.ts";
+import { buildStackPublishPreview } from "./publish.ts";
+import type { StackExecResult } from "./types.ts";
+
+let repoPath = "";
+let headSha = "";
+
+beforeAll(async () => {
+	repoPath = mkdtempSync(join(tmpdir(), "publish-preview-test-"));
+
+	await Bun.$`git init ${repoPath}`.quiet();
+	await Bun.$`git -C ${repoPath} config user.name "Test User"`.quiet();
+	await Bun.$`git -C ${repoPath} config user.email "test@example.com"`.quiet();
+
+	writeFileSync(join(repoPath, "README.md"), "initial\n");
+	await Bun.$`git -C ${repoPath} add README.md`.quiet();
+	await Bun.$`git -C ${repoPath} commit -m "Initial commit"`.quiet();
+
+	headSha = (await Bun.$`git -C ${repoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+});
+
+afterAll(() => {
+	if (repoPath) rmSync(repoPath, { recursive: true, force: true });
+});
+
+describe("buildStackPublishPreview", () => {
+	test("uses DAG dependency bases instead of linear previous branch", async () => {
+		const execResult: StackExecResult = {
+			run_id: "run-1",
+			source_copy_branch: "newpr/stack-source/pr-42",
+			group_commits: [
+				{ group_id: "A", commit_sha: headSha, tree_sha: headSha, branch_name: "stack/a", pr_title: "A title" },
+				{ group_id: "B", commit_sha: headSha, tree_sha: headSha, branch_name: "stack/b", pr_title: "B title" },
+				{ group_id: "C", commit_sha: headSha, tree_sha: headSha, branch_name: "stack/c", pr_title: "C title" },
+			],
+			final_tree_sha: headSha,
+			verified: true,
+		};
+
+		const prMeta: PrMeta = {
+			pr_number: 42,
+			pr_title: "Source PR",
+			pr_url: "https://github.com/acme/repo/pull/42",
+			base_branch: "main",
+			head_branch: "feature/source",
+			author: "tester",
+			total_files_changed: 3,
+			total_additions: 10,
+			total_deletions: 2,
+			analyzed_at: new Date().toISOString(),
+			model_used: "test-model",
+		};
+
+		const preview = await buildStackPublishPreview({
+			repo_path: repoPath,
+			exec_result: execResult,
+			pr_meta: prMeta,
+			base_branch: "main",
+			owner: "acme",
+			repo: "repo",
+			plan_groups: [
+				{ id: "A", name: "A", description: "A desc", files: ["a.ts"], order: 0, deps: [] },
+				{ id: "B", name: "B", description: "B desc", files: ["b.ts"], order: 1, deps: ["A"] },
+				{ id: "C", name: "C", description: "C desc", files: ["c.ts"], order: 2, deps: [] },
+			],
+		});
+
+		const itemById = new Map(preview.items.map((item) => [item.group_id, item]));
+
+		expect(itemById.get("A")?.base_branch).toBe("main");
+		expect(itemById.get("B")?.base_branch).toBe("stack/a");
+		expect(itemById.get("C")?.base_branch).toBe("main");
+
+		expect(itemById.get("B")?.title).toContain("L1");
+		expect(itemById.get("C")?.title).toContain("L0");
+		expect(itemById.get("B")?.body).toContain("Stack L1");
+		expect(itemById.get("C")?.body).toContain("Stack L0");
+	});
+});

package/src/stack/publish.ts

@@ -145,6 +145,24 @@ function buildEffectiveGroupMeta(
 	});
 }
 
+function resolvePrBaseBranch(
+	groupId: string,
+	baseBranch: string,
+	planGroups: StackPublishGroupMeta[] | undefined,
+	branchByGroupId: Map<string, string>,
+): string {
+	const planGroup = planGroups?.find((g) => g.id === groupId);
+	const directDeps: string[] = planGroup?.deps ?? [];
+	if (directDeps.length > 0) {
+		const depBranch = directDeps
+			.map((dep: string) => branchByGroupId.get(dep))
+			.find((b: string | undefined): b is string => Boolean(b));
+		if (depBranch) return depBranch;
+	}
+
+	return baseBranch;
+}
+
 function isPreviewCompatible(execResult: StackExecResult, preview: StackPublishPreviewResult | null | undefined): boolean {
 	if (!preview || preview.items.length === 0) return false;
 	if (preview.items.length !== execResult.group_commits.length) return false;
@@ -502,18 +520,6 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 
 	const dagLevelMap = buildDagLevelMap(exec_result.group_commits, groupMetaById);
 
-	const resolvePrBase = (gc: typeof exec_result.group_commits[number], index: number): string => {
-		const planGroup = plan_groups?.find((g) => g.id === gc.group_id);
-		const directDeps: string[] = planGroup?.deps ?? [];
-		if (directDeps.length > 0) {
-			const depBranch = directDeps
-				.map((dep: string) => branchByGroupId.get(dep))
-				.find((b: string | undefined): b is string => Boolean(b));
-			if (depBranch) return depBranch;
-		}
-		return index === 0 ? base_branch : (exec_result.group_commits[index - 1]?.branch_name ?? base_branch);
-	};
-
 	for (const gc of exec_result.group_commits) {
 		const pushResult = await Bun.$`git -C ${repo_path} push origin refs/heads/${gc.branch_name}:refs/heads/${gc.branch_name} --force-with-lease`.quiet().nothrow();
 
@@ -536,7 +542,7 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 		if (!branchInfo?.pushed) continue;
 
 		const previewItem = previewByGroup.get(gc.group_id);
-		const prBase = previewItem?.base_branch ?? resolvePrBase(gc, i);
+		const prBase = previewItem?.base_branch ?? resolvePrBaseBranch(gc.group_id, base_branch, plan_groups, branchByGroupId);
 		if (!prBase) continue;
 
 		const order = i + 1;
@@ -553,6 +559,7 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 			prBase,
 			gc.branch_name,
 			llmPrefillByGroup.get(gc.group_id),
+			dagLevel,
 		);
 
 		const prResult = await runWithBodyFile(
@@ -580,7 +587,7 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 		}
 	}
 
-	await updatePrBodies(ghRepo, prs, pr_meta, prTemplate, groupMetaById, llmPrefillByGroup, previewByGroup);
+	await updatePrBodies(ghRepo, prs, pr_meta, prTemplate, groupMetaById, llmPrefillByGroup, previewByGroup, dagLevelMap);
 	await postStackNavigationComments(ghRepo, prs, dagLevelMap);
 
 	return { branches, prs };
@@ -593,6 +600,8 @@ export async function buildStackPublishPreview(input: PublishInput): Promise<Sta
 	const prTemplate = prTemplateData?.content ?? null;
 	const total = exec_result.group_commits.length;
 	const groupMetaById = buildGroupMetaMap(plan_groups);
+	const branchByGroupId = new Map(exec_result.group_commits.map((gc) => [gc.group_id, gc.branch_name]));
+	const dagLevelMap = buildDagLevelMap(exec_result.group_commits, groupMetaById);
 	const effectiveGroups = buildEffectiveGroupMeta(exec_result, groupMetaById);
 	const llmPrefillByGroup = await generateTemplatePrefillWithLlm(
 		llm_client,
@@ -604,8 +613,9 @@ export async function buildStackPublishPreview(input: PublishInput): Promise<Sta
 
 	const items = exec_result.group_commits.map((gc, i) => {
 		const order = i + 1;
-		const title = buildStackPrTitle(gc, pr_meta, order, total);
-		const prBase = i === 0 ? base_branch : exec_result.group_commits[i - 1]?.branch_name ?? base_branch;
+		const dagLevel = dagLevelMap.get(gc.group_id);
+		const title = buildStackPrTitle(gc, pr_meta, order, total, dagLevel);
+		const prBase = resolvePrBaseBranch(gc.group_id, base_branch, plan_groups, branchByGroupId);
 		const groupMeta = groupMetaById.get(gc.group_id);
 		return {
 			group_id: gc.group_id,
@@ -624,6 +634,7 @@ export async function buildStackPublishPreview(input: PublishInput): Promise<Sta
 				prBase,
 				gc.branch_name,
 				llmPrefillByGroup.get(gc.group_id),
+				dagLevel,
 			),
 		};
 	});
@@ -642,6 +653,7 @@ async function updatePrBodies(
 	groupMetaById: Map<string, StackPublishGroupMeta>,
 	llmPrefillByGroup: Map<string, SectionBullets>,
 	previewByGroup: Map<string, StackPublishPreviewItem>,
+	dagLevelMap: Map<string, number>,
 ): Promise<void> {
 	if (prs.length === 0) return;
 
@@ -650,6 +662,7 @@ async function updatePrBodies(
 		const previewItem = previewByGroup.get(pr.group_id);
 		const previewBody = previewItem?.body;
 		const groupMeta = groupMetaById.get(pr.group_id);
+		const dagLevel = dagLevelMap.get(pr.group_id);
 		const body = previewBody ?? buildFullBody(
 			pr,
 			i,
@@ -660,6 +673,7 @@ async function updatePrBodies(
 			pr.base_branch,
 			pr.head_branch,
 			llmPrefillByGroup.get(pr.group_id),
+			dagLevel,
 		);
 		const editResult = await runWithBodyFile(
 			body,
@@ -718,8 +732,9 @@ function buildPlaceholderBody(
 	baseBranch?: string,
 	headBranch?: string,
 	llmBullets?: SectionBullets,
+	dagLevel?: number,
 ): string {
-	return buildDescriptionBody(groupId, order, total, prMeta, prTemplate, groupMeta, baseBranch, headBranch, llmBullets);
+	return buildDescriptionBody(groupId, order, total, prMeta, prTemplate, groupMeta, baseBranch, headBranch, llmBullets, dagLevel);
 }
 
 function buildStackPrTitle(
@@ -791,8 +806,9 @@ function buildFullBody(
 	baseBranch?: string,
 	headBranch?: string,
 	llmBullets?: SectionBullets,
+	dagLevel?: number,
 ): string {
-	return buildDescriptionBody(current.group_id, index + 1, allPrs.length, prMeta, prTemplate, groupMeta, baseBranch, headBranch, llmBullets);
+	return buildDescriptionBody(current.group_id, index + 1, allPrs.length, prMeta, prTemplate, groupMeta, baseBranch, headBranch, llmBullets, dagLevel);
 }
 
 function buildStackNavigationComment(

package/src/stack/types.ts

@@ -107,15 +107,22 @@ export interface StackGroupStats {
 	files_deleted: number;
 }
 
+export interface StackFileStats {
+	additions: number;
+	deletions: number;
+}
+
 export interface StackGroup {
 	id: string;
 	name: string;
 	type: GroupType;
 	description: string;
 	files: string[];
-	deps: string[]; // groupIds
+	deps: string[];
+	explicit_deps?: string[];
 	order: number;
 	stats?: StackGroupStats;
+	file_stats?: Record<string, StackFileStats>;
 	pr_title?: string;
 }
 
@@ -123,7 +130,8 @@ export interface StackPlan {
 	base_sha: string;
 	head_sha: string;
 	groups: StackGroup[];
-	expected_trees: Map<string, string>; // groupId -> treeSha
+	expected_trees: Map<string, string>;
+	ancestor_sets: Map<string, string[]>;
 }
 
 // ============================================================================

package/src/stack/verify.ts

@@ -6,6 +6,7 @@ export interface VerifyInput {
 	head_sha: string;
 	exec_result: StackExecResult;
 	ownership: Map<string, string>;
+	group_deps?: Map<string, string[]>;
 }
 
 export interface VerifyResult {
@@ -16,7 +17,7 @@ export interface VerifyResult {
 }
 
 export async function verifyStack(input: VerifyInput): Promise<VerifyResult> {
-	const { repo_path, base_sha, head_sha, exec_result, ownership } = input;
+	const { repo_path, base_sha, head_sha, exec_result, ownership, group_deps } = input;
 	const errors: string[] = [];
 	const warnings: string[] = [];
 	const structuredWarnings: StackWarning[] = [];
@@ -25,7 +26,7 @@ export async function verifyStack(input: VerifyInput): Promise<VerifyResult> {
 	const unionMissing: string[] = [];
 	const unionExtra: string[] = [];
 
-	await verifyPerGroupDiffScope(repo_path, base_sha, exec_result, ownership, warnings, scopeLeaks);
+	await verifyPerGroupDiffScope(repo_path, base_sha, exec_result, ownership, group_deps ?? new Map(), warnings, scopeLeaks);
 	await verifyUnionCompleteness(repo_path, base_sha, head_sha, exec_result, warnings, unionMissing, unionExtra);
 	await verifyFinalTreeEquivalence(repo_path, head_sha, exec_result, errors);
 
@@ -70,17 +71,26 @@ async function verifyPerGroupDiffScope(
 	baseSha: string,
 	execResult: StackExecResult,
 	ownership: Map<string, string>,
+	groupDeps: Map<string, string[]>,
 	warnings: string[],
 	scopeLeaks: string[],
 ): Promise<void> {
-	let prevCommitSha = baseSha;
+	const commitByGroupId = new Map<string, string>();
+	for (const gc of execResult.group_commits) {
+		commitByGroupId.set(gc.group_id, gc.commit_sha);
+	}
 
 	for (const gc of execResult.group_commits) {
-		const diffResult = await Bun.$`git -C ${repoPath} diff-tree -r --raw -z --no-commit-id ${prevCommitSha} ${gc.commit_sha}`.quiet().nothrow();
+		const parentTree = await resolveScopeParentTree(repoPath, baseSha, gc.group_id, groupDeps, commitByGroupId);
+		if (!parentTree) {
+			warnings.push(`Failed to resolve parent tree for group "${gc.group_id}"`);
+			continue;
+		}
+
+		const diffResult = await Bun.$`git -C ${repoPath} diff-tree -r --raw -z --no-commit-id ${parentTree} ${gc.tree_sha}`.quiet().nothrow();
 
 		if (diffResult.exitCode !== 0) {
 			warnings.push(`Failed to diff group "${gc.group_id}": ${diffResult.stderr.toString().trim()}`);
-			prevCommitSha = gc.commit_sha;
 			continue;
 		}
 
@@ -89,16 +99,62 @@ async function verifyPerGroupDiffScope(
 		for (const path of changedPaths) {
 			const fileOwner = ownership.get(path);
 			if (fileOwner !== gc.group_id) {
-				const detail = `"${path}" in "${gc.group_id}" diff, owned by "${fileOwner ?? "unassigned"}"`;
 				warnings.push(
 					`Group "${gc.group_id}" diff contains file "${path}" owned by "${fileOwner ?? "unassigned"}"`,
 				);
-				scopeLeaks.push(detail);
+				scopeLeaks.push(`"${path}" in "${gc.group_id}" diff, owned by "${fileOwner ?? "unassigned"}"`);
 			}
 		}
+	}
+}
+
+async function resolveScopeParentTree(
+	repoPath: string,
+	baseSha: string,
+	groupId: string,
+	groupDeps: Map<string, string[]>,
+	commitByGroupId: Map<string, string>,
+): Promise<string | null> {
+	const deps = groupDeps.get(groupId) ?? [];
+	if (deps.length === 0) {
+		return resolveTreeForRef(repoPath, baseSha);
+	}
+
+	const parentCommits: string[] = [];
+	for (const dep of deps) {
+		const depCommit = commitByGroupId.get(dep);
+		if (!depCommit) continue;
+		parentCommits.push(depCommit);
+	}
+
+	if (parentCommits.length === 0) return resolveTreeForRef(repoPath, baseSha);
+	if (parentCommits.length === 1) return resolveTreeForRef(repoPath, parentCommits[0]!);
+
+	let mergedCommit = parentCommits[0]!;
+	let mergedTree: string | null = null;
+	for (let i = 1; i < parentCommits.length; i++) {
+		const nextParentCommit = parentCommits[i]!;
+		const mergeResult = await Bun.$`git -C ${repoPath} merge-tree --write-tree --allow-unrelated-histories ${mergedCommit} ${nextParentCommit}`.quiet().nothrow();
+		if (mergeResult.exitCode !== 0) return null;
+		const nextTree = mergeResult.stdout.toString().trim().split("\n")[0]?.trim();
+		if (!nextTree) return null;
+		mergedTree = nextTree;
 
-		prevCommitSha = gc.commit_sha;
+		const mergedCommitResult = await Bun.$`git -C ${repoPath} commit-tree ${mergedTree} -p ${mergedCommit} -p ${nextParentCommit} -m "newpr synthetic verify merged parent"`.quiet().nothrow();
+		if (mergedCommitResult.exitCode !== 0) return null;
+		mergedCommit = mergedCommitResult.stdout.toString().trim();
+		if (!mergedCommit) return null;
 	}
+
+	if (!mergedTree) return resolveTreeForRef(repoPath, mergedCommit);
+	return mergedTree;
+}
+
+async function resolveTreeForRef(repoPath: string, ref: string): Promise<string | null> {
+	const result = await Bun.$`git -C ${repoPath} rev-parse ${ref}^{tree}`.quiet().nothrow();
+	if (result.exitCode !== 0) return null;
+	const tree = result.stdout.toString().trim();
+	return tree.length > 0 ? tree : null;
 }
 
 async function verifyUnionCompleteness(
@@ -119,18 +175,19 @@ async function verifyUnionCompleteness(
 
 	const expectedPaths = new Set(extractPathsFromRawDiff(expectedResult.stdout));
 
-	const actualPaths = new Set<string>();
-	let prevSha = baseSha;
-	for (const gc of execResult.group_commits) {
-		const diffResult = await Bun.$`git -C ${repoPath} diff-tree -r --raw -z --no-commit-id ${prevSha} ${gc.commit_sha}`.quiet().nothrow();
-
-		if (diffResult.exitCode === 0) {
-			for (const path of extractPathsFromRawDiff(diffResult.stdout)) {
-				actualPaths.add(path);
-			}
-		}
-		prevSha = gc.commit_sha;
+	const baseTreeResult = await Bun.$`git -C ${repoPath} rev-parse ${baseSha}^{tree}`.quiet().nothrow();
+	if (baseTreeResult.exitCode !== 0) {
+		warnings.push(`Failed to get base tree: ${baseTreeResult.stderr.toString().trim()}`);
+		return;
 	}
+	const baseTree = baseTreeResult.stdout.toString().trim();
+	const finalTree = execResult.final_tree_sha;
+	if (!finalTree) return;
+
+	const actualResult = await Bun.$`git -C ${repoPath} diff-tree -r --raw -z ${baseTree} ${finalTree}`.quiet().nothrow();
+	const actualPaths = actualResult.exitCode === 0
+		? new Set(extractPathsFromRawDiff(actualResult.stdout))
+		: new Set<string>();
 
 	for (const path of expectedPaths) {
 		if (!actualPaths.has(path)) {