newpr 1.0.20 → 1.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "AI-powered large PR review tool - understand PRs with 1000+ lines of changes",
   "module": "src/cli/index.ts",
   "type": "module",
@@ -74,6 +74,7 @@
     "ink-text-input": "6.0.0",
     "katex": "^0.16.28",
     "lucide-react": "^0.567.0",
+    "meriyah": "^7.1.0",
     "react": "19.1.0",
     "react-dom": "19.1.0",
     "react-markdown": "^10.1.0",

package/src/stack/co-change.ts

@@ -0,0 +1,64 @@
+import type { DeltaEntry } from "./types.ts";
+
+export interface CoChangeResult {
+	pairs: Map<string, number>;
+	totalCommits: number;
+}
+
+export function buildCoChangePairs(deltas: DeltaEntry[]): CoChangeResult {
+	const pairs = new Map<string, number>();
+
+	for (const delta of deltas) {
+		const files = delta.changes.map((c) => c.path);
+		for (let i = 0; i < files.length; i++) {
+			for (let j = i + 1; j < files.length; j++) {
+				const key = [files[i]!, files[j]!].sort().join("|||");
+				pairs.set(key, (pairs.get(key) ?? 0) + 1);
+			}
+		}
+	}
+
+	return { pairs, totalCommits: deltas.length };
+}
+
+export async function buildHistoricalCoChangePairs(
+	repoPath: string,
+	filePaths: string[],
+	maxCommits = 200,
+): Promise<CoChangeResult> {
+	if (filePaths.length === 0) return { pairs: new Map(), totalCommits: 0 };
+
+	const result = await Bun.$`git -C ${repoPath} log --name-only --pretty=format:"%H" -n ${maxCommits} -- ${filePaths}`.quiet().nothrow();
+	if (result.exitCode !== 0) return { pairs: new Map(), totalCommits: 0 };
+
+	const fileSet = new Set(filePaths);
+	const lines = result.stdout.toString().split("\n");
+	const pairs = new Map<string, number>();
+	let totalCommits = 0;
+	let currentFiles: string[] = [];
+
+	const flushCommit = () => {
+		if (currentFiles.length < 2) return;
+		for (let i = 0; i < currentFiles.length; i++) {
+			for (let j = i + 1; j < currentFiles.length; j++) {
+				const key = [currentFiles[i]!, currentFiles[j]!].sort().join("|||");
+				pairs.set(key, (pairs.get(key) ?? 0) + 1);
+			}
+		}
+		totalCommits++;
+		currentFiles = [];
+	};
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		if (/^[0-9a-f]{40}$/i.test(trimmed)) {
+			flushCommit();
+		} else if (fileSet.has(trimmed)) {
+			currentFiles.push(trimmed);
+		}
+	}
+	flushCommit();
+
+	return { pairs, totalCommits };
+}

package/src/stack/confidence-score.ts

@@ -0,0 +1,242 @@
+import type { FileGroup } from "../types/output.ts";
+import type { FileSymbols } from "./symbol-flow.ts";
+
+export type LayerType = "schema" | "refactor" | "codegen" | "core" | "integration" | "ui" | "test" | "unknown";
+
+const LAYER_ORDER: Record<LayerType, number> = {
+	schema: 0,
+	codegen: 1,
+	refactor: 2,
+	core: 3,
+	integration: 4,
+	ui: 5,
+	test: 6,
+	unknown: 3,
+};
+
+const SCHEMA_PATH_RE = /\/(schema|types?|const|constants|config|model|interface)s?(?:\/|\.)/i;
+const SCHEMA_SUFFIX_RE = /\.(schema|types?|const|d)\.[tj]sx?$/i;
+const CODEGEN_PATH_RE = /\/(generated?|__generated?|\.generated?)\//i;
+const TEST_PATH_RE = /\.(test|spec)\.[tj]sx?$|^\/?(__tests?__|tests?)\//i;
+const UI_PATH_RE = /\.(tsx|css|scss|sass|less|html|vue|svelte)$|\/ui\/|\/components?\//i;
+const INTEGRATION_PATH_RE = /\/(?:hooks?|providers?|context|store|api|adapters?|container|wiring)\//i;
+
+function classifyLayer(filePath: string, symbols: FileSymbols | undefined): LayerType {
+	if (TEST_PATH_RE.test(filePath)) return "test";
+	if (CODEGEN_PATH_RE.test(filePath)) return "codegen";
+	if (SCHEMA_SUFFIX_RE.test(filePath) || SCHEMA_PATH_RE.test(filePath)) return "schema";
+	if (UI_PATH_RE.test(filePath)) return "ui";
+	if (INTEGRATION_PATH_RE.test(filePath)) return "integration";
+
+	if (symbols) {
+		const importCount = symbols.imports.reduce((sum, imp) => sum + imp.names.length, 0);
+		const exportCount = symbols.exports.length;
+		if (importCount > 6 && exportCount < 3) return "integration";
+		if (exportCount > 5 && importCount < 3) return "schema";
+	}
+
+	return "core";
+}
+
+export function classifyGroupLayer(group: FileGroup, symbolMap: Map<string, FileSymbols>): LayerType {
+	const counts: Partial<Record<LayerType, number>> = {};
+	for (const file of group.files) {
+		const layer = classifyLayer(file, symbolMap.get(file));
+		counts[layer] = (counts[layer] ?? 0) + 1;
+	}
+	if (Object.keys(counts).length === 0) return "unknown";
+	let best: LayerType = "unknown";
+	let bestCount = 0;
+	for (const [layer, count] of Object.entries(counts) as [LayerType, number][]) {
+		if (count > bestCount) { best = layer; bestCount = count; }
+	}
+	return best;
+}
+
+export function getLayerOrder(layer: LayerType): number {
+	return LAYER_ORDER[layer];
+}
+
+export interface ConfidenceBreakdown {
+	import: number;
+	directory: number;
+	symbol: number;
+	coChange: number;
+	layerBonus: number;
+}
+
+export interface GroupScore {
+	groupName: string;
+	total: number;
+	breakdown: ConfidenceBreakdown;
+}
+
+function directoryScore(file: string, group: FileGroup): number {
+	const fileParts = file.split("/");
+	let maxOverlap = 0;
+	for (const gf of group.files) {
+		const gParts = gf.split("/");
+		let overlap = 0;
+		const limit = Math.min(fileParts.length - 1, gParts.length - 1);
+		for (let i = 0; i < limit; i++) {
+			if (fileParts[i] === gParts[i]) overlap++;
+			else break;
+		}
+		if (overlap > maxOverlap) maxOverlap = overlap;
+	}
+	return Math.min(1, maxOverlap / 4);
+}
+
+function importScore(
+	file: string,
+	group: FileGroup,
+	symbolMap: Map<string, FileSymbols>,
+): number {
+	const fileSyms = symbolMap.get(file);
+	if (!fileSyms) return 0;
+
+	const groupFileSet = new Set(group.files);
+	let score = 0;
+
+	for (const imp of fileSyms.imports) {
+		if (groupFileSet.has(imp.from)) {
+			score += Math.min(1, imp.names.length / 3);
+		}
+	}
+
+	for (const gf of group.files) {
+		const gSyms = symbolMap.get(gf);
+		if (!gSyms) continue;
+		for (const imp of gSyms.imports) {
+			if (imp.from === file) {
+				score += Math.min(1, imp.names.length / 3);
+			}
+		}
+	}
+
+	return Math.min(1, score / 3);
+}
+
+function symbolScore(
+	file: string,
+	group: FileGroup,
+	symbolMap: Map<string, FileSymbols>,
+): number {
+	const fileSyms = symbolMap.get(file);
+	if (!fileSyms || fileSyms.exports.length === 0) return 0;
+
+	const fileExportSet = new Set(fileSyms.exports);
+	let sharedCount = 0;
+
+	for (const gf of group.files) {
+		const gSyms = symbolMap.get(gf);
+		if (!gSyms) continue;
+		for (const imp of gSyms.imports) {
+			for (const name of imp.names) {
+				if (fileExportSet.has(name)) sharedCount++;
+			}
+		}
+		for (const imp of fileSyms.imports) {
+			for (const name of gSyms.exports) {
+				if (imp.names.includes(name)) sharedCount++;
+			}
+		}
+	}
+
+	return Math.min(1, sharedCount / 5);
+}
+
+function coChangeScore(
+	file: string,
+	group: FileGroup,
+	coChangePairs: Map<string, number>,
+	totalCommits: number,
+): number {
+	if (totalCommits === 0) return 0;
+	let total = 0;
+	for (const gf of group.files) {
+		const key = [file, gf].sort().join("|||");
+		total += coChangePairs.get(key) ?? 0;
+	}
+	return Math.min(1, total / (totalCommits * 0.5));
+}
+
+function layerBonus(
+	file: string,
+	group: FileGroup,
+	symbolMap: Map<string, FileSymbols>,
+): number {
+	const fileLayer = classifyLayer(file, symbolMap.get(file));
+	const groupLayer = classifyGroupLayer(group, symbolMap);
+	if (fileLayer === groupLayer) return 0.3;
+	if (Math.abs(LAYER_ORDER[fileLayer] - LAYER_ORDER[groupLayer]) === 1) return 0.1;
+	return 0;
+}
+
+export function scoreFileAgainstGroups(
+	file: string,
+	groups: FileGroup[],
+	symbolMap: Map<string, FileSymbols>,
+	coChangePairs: Map<string, number>,
+	totalCommits: number,
+): GroupScore[] {
+	return groups.map((group) => {
+		const breakdown: ConfidenceBreakdown = {
+			import: importScore(file, group, symbolMap) * 0.4,
+			directory: directoryScore(file, group) * 0.3,
+			symbol: symbolScore(file, group, symbolMap) * 0.2,
+			coChange: coChangeScore(file, group, coChangePairs, totalCommits) * 0.1,
+			layerBonus: layerBonus(file, group, symbolMap),
+		};
+		const total = breakdown.import + breakdown.directory + breakdown.symbol + breakdown.coChange + breakdown.layerBonus;
+		return { groupName: group.name, total, breakdown };
+	}).sort((a, b) => b.total - a.total);
+}
+
+export interface ReassignmentResult {
+	reassigned: Map<string, string>;
+	warnings: Array<{ file: string; from: string; to: string; confidence: number }>;
+}
+
+const REASSIGN_THRESHOLD = 0.25;
+const MIN_ADVANTAGE = 0.15;
+
+export function computeConfidenceReassignments(
+	ownership: Map<string, string>,
+	groups: FileGroup[],
+	symbolMap: Map<string, FileSymbols>,
+	coChangePairs: Map<string, number>,
+	totalCommits: number,
+): ReassignmentResult {
+	const reassigned = new Map<string, string>();
+	const warnings: ReassignmentResult["warnings"] = [];
+
+	const groupByName = new Map(groups.map((g) => [g.name, g]));
+
+	for (const [file, currentGroup] of ownership) {
+		const scores = scoreFileAgainstGroups(file, groups, symbolMap, coChangePairs, totalCommits);
+		if (scores.length === 0) continue;
+
+		const best = scores[0]!;
+		if (best.groupName === currentGroup) continue;
+		if (best.total < REASSIGN_THRESHOLD) continue;
+
+		const currentScore = scores.find((s) => s.groupName === currentGroup);
+		const currentTotal = currentScore?.total ?? 0;
+
+		if (best.total - currentTotal < MIN_ADVANTAGE) continue;
+
+		const targetGroup = groupByName.get(best.groupName);
+		if (!targetGroup) continue;
+
+		reassigned.set(file, best.groupName);
+		warnings.push({
+			file,
+			from: currentGroup,
+			to: best.groupName,
+			confidence: best.total,
+		});
+	}
+
+	return { reassigned, warnings };
+}

package/src/stack/delta.ts

@@ -183,22 +183,57 @@ function checkForUnsupportedModes(
 	}
 }
 
+async function resolveParentTree(
+	repoPath: string,
+	baseSha: string,
+	gid: string,
+	expectedTrees: Map<string, string>,
+	dagParents: Map<string, string[]>,
+): Promise<string | null> {
+	const parentIds = dagParents.get(gid) ?? [];
+
+	if (parentIds.length === 0) {
+		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]!;
+
+	let mergedTree = parentTrees[0]!;
+	for (let i = 1; i < parentTrees.length; i++) {
+		const mergeResult = await Bun.$`git -C ${repoPath} merge-tree --write-tree --allow-unrelated-histories ${mergedTree} ${parentTrees[i]!}`.quiet().nothrow();
+		if (mergeResult.exitCode === 0) {
+			mergedTree = mergeResult.stdout.toString().trim().split("\n")[0]!.trim();
+		}
+	}
+
+	return mergedTree;
+}
+
 export async function computeGroupStats(
 	repoPath: string,
 	baseSha: string,
 	orderedGroupIds: string[],
 	expectedTrees: Map<string, string>,
+	dagParents?: Map<string, string[]>,
 ): Promise<Map<string, StackGroupStats>> {
 	const stats = new Map<string, StackGroupStats>();
+	const linearParents = new Map<string, string[]>(
+		orderedGroupIds.map((gid, i) => [gid, i === 0 ? [] : [orderedGroupIds[i - 1]!]]),
+	);
+	const effectiveDagParents = dagParents ?? linearParents;
 
 	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]!);
+		const prevTree = await resolveParentTree(repoPath, baseSha, gid, expectedTrees, effectiveDagParents);
 		if (!prevTree) continue;
 
 		const numstatResult = await Bun.$`git -C ${repoPath} diff-tree --numstat -r ${prevTree} ${tree}`.quiet().nothrow();

package/src/stack/execute.ts

@@ -4,6 +4,7 @@ import type {
 	StackExecResult,
 	GroupCommitInfo,
 } from "./types.ts";
+import { buildAncestorSets } from "./plan.ts";
 
 export class StackExecutionError extends Error {
 	constructor(message: string) {
@@ -78,6 +79,10 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 	const groupRank = new Map<string, number>();
 	groupOrder.forEach((gid, idx) => groupRank.set(gid, idx));
 
+	const dagParents = new Map<string, string[]>();
+	for (const g of plan.groups) dagParents.set(g.id, g.deps ?? []);
+	const ancestorSets = buildAncestorSets(groupOrder, dagParents);
+
 	try {
 		for (let i = 0; i < groupOrder.length; i++) {
 			const idxFile = `/tmp/newpr-exec-idx-${runId}-${i}`;
@@ -101,8 +106,12 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 				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++) {
+				for (let idxNum = 0; idxNum < groupOrder.length; idxNum++) {
+					const targetGroupId = groupOrder[idxNum]!;
+					const isOwner = targetGroupId === fileGroupId;
+					const isAncestorOfOwner = ancestorSets.get(targetGroupId)?.has(fileGroupId) ?? false;
+					if (!isOwner && !isAncestorOfOwner) continue;
+
 					let batch = batchPerIndex.get(idxNum);
 					if (!batch) {
 						batch = [];
@@ -137,7 +146,7 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 		}
 
 		const groupCommits: GroupCommitInfo[] = [];
-		let prevCommitSha = plan.base_sha;
+		const commitBySha = new Map<string, string>();
 
 		for (let i = 0; i < groupOrder.length; i++) {
 			const idxFile = tmpIndexFiles[i];
@@ -162,7 +171,13 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 
 			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({
+			const directParents = (group.deps ?? []).length > 0
+				? group.deps.map((dep) => commitBySha.get(dep) ?? plan.base_sha)
+				: [groupCommits[i - 1]?.commit_sha ?? plan.base_sha];
+
+			const parentArgs = directParents.flatMap((p) => ["-p", p]);
+
+			const commitTree = await Bun.$`git -C ${repo_path} commit-tree ${treeSha} ${parentArgs} -m ${commitMessage}`.env({
 				GIT_AUTHOR_NAME: pr_author.name,
 				GIT_AUTHOR_EMAIL: pr_author.email,
 				GIT_COMMITTER_NAME: pr_author.name,
@@ -175,6 +190,7 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 				);
 			}
 			const commitSha = commitTree.stdout.toString().trim();
+			commitBySha.set(gid, commitSha);
 
 			const branchName = buildStackBranchName(pr_number, head_branch, group);
 
@@ -193,8 +209,6 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 				branch_name: branchName,
 				pr_title: group.pr_title,
 			});
-
-			prevCommitSha = commitSha;
 		}
 
 		const lastCommit = groupCommits[groupCommits.length - 1];

package/src/stack/feasibility.test.ts

@@ -76,7 +76,7 @@ describe("checkFeasibility", () => {
 		expect(result.feasible).toBe(true);
 	});
 
-	test("declared deps creating cycle → infeasible", () => {
+	test("declared deps with mutual cycle → still feasible (cycle broken automatically)", () => {
 		const deltas: DeltaEntry[] = [
 			makeDelta("c1", "base", [{ status: "A", path: "a.ts" }]),
 			makeDelta("c2", "c1", [{ status: "A", path: "b.ts" }]),
@@ -94,9 +94,8 @@ describe("checkFeasibility", () => {
 
 		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
 
-		expect(result.feasible).toBe(false);
-		expect(result.cycle).toBeDefined();
-		expect(result.cycle?.group_cycle.length).toBeGreaterThan(0);
+		expect(result.feasible).toBe(true);
+		expect(result.ordered_group_ids).toHaveLength(2);
 	});
 
 	test("single file in one group → no edges, feasible", () => {
@@ -139,7 +138,7 @@ describe("checkFeasibility", () => {
 		expect(result.feasible).toBe(true);
 	});
 
-	test("mutual declared deps create cycle → infeasible", () => {
+	test("mutual declared deps create cycle → cycle broken, still feasible", () => {
 		const deltas: DeltaEntry[] = [
 			makeDelta("c1", "base", [{ status: "A", path: "a.ts" }]),
 			makeDelta("c2", "c1", [{ status: "A", path: "b.ts" }]),
@@ -156,8 +155,8 @@ describe("checkFeasibility", () => {
 		]);
 
 		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
-		expect(result.feasible).toBe(false);
-		expect(result.cycle).toBeDefined();
+		expect(result.feasible).toBe(true);
+		expect(result.ordered_group_ids).toHaveLength(2);
 	});
 
 	test("declared deps without cycle → feasible with correct order", () => {

package/src/stack/feasibility.ts

@@ -30,7 +30,64 @@ export function checkFeasibility(input: FeasibilityInput): FeasibilityResult {
 	}
 
 	const deduped = deduplicateEdges(edges);
-	const result = topologicalSort(Array.from(allGroups), deduped, deltas, ownership);
+	const acyclic = breakAllCycles(deduped);
+	const result = topologicalSort(Array.from(allGroups), acyclic, deltas, ownership);
+
+	return result;
+}
+
+function breakAllCycles(edges: ConstraintEdge[]): ConstraintEdge[] {
+	const edgeSet = new Set(edges.map((e) => `${e.from}→${e.to}`));
+	const withoutMutual: ConstraintEdge[] = [];
+	for (const edge of edges) {
+		const reverseKey = `${edge.to}→${edge.from}`;
+		if (edgeSet.has(reverseKey) && edge.kind === "dependency") continue;
+		withoutMutual.push(edge);
+	}
+	return breakRemainingCycles(withoutMutual);
+}
+
+function hasCycle(groups: string[], edges: ConstraintEdge[]): boolean {
+	const adjacency = new Map<string, string[]>();
+	for (const g of groups) adjacency.set(g, []);
+	for (const e of edges) adjacency.get(e.from)?.push(e.to);
+
+	const WHITE = 0, GRAY = 1, BLACK = 2;
+	const color = new Map<string, number>(groups.map((g) => [g, WHITE]));
+
+	const dfs = (node: string): boolean => {
+		color.set(node, GRAY);
+		for (const neighbor of adjacency.get(node) ?? []) {
+			if (color.get(neighbor) === GRAY) return true;
+			if (color.get(neighbor) === WHITE && dfs(neighbor)) return true;
+		}
+		color.set(node, BLACK);
+		return false;
+	};
+
+	for (const g of groups) {
+		if (color.get(g) === WHITE && dfs(g)) return true;
+	}
+	return false;
+}
+
+function breakRemainingCycles(edges: ConstraintEdge[]): ConstraintEdge[] {
+	const groups = [...new Set(edges.flatMap((e) => [e.from, e.to]))];
+	if (!hasCycle(groups, edges)) return edges;
+
+	const prioritized = [...edges].sort((a, b) => {
+		const kindScore = (e: ConstraintEdge) =>
+			e.kind === "path-order" ? 0 : e.kind === "dependency" ? 1 : 2;
+		return kindScore(a) - kindScore(b);
+	});
+
+	const result: ConstraintEdge[] = [];
+	for (const edge of prioritized) {
+		result.push(edge);
+		if (hasCycle(groups, result)) {
+			result.pop();
+		}
+	}
 
 	return result;
 }
@@ -62,26 +119,24 @@ function addPathOrderEdges(
 
 	for (const [path, seq] of pathEditSequences) {
 		const collapsed = collapseConsecutiveDuplicates(seq);
-
-		for (let i = 0; i < collapsed.length - 1; i++) {
-			const prev = collapsed[i];
-			const next = collapsed[i + 1];
-			if (!prev || !next) continue;
-			if (prev.group_id === next.group_id) continue;
-
-			edges.push({
-				from: prev.group_id,
-				to: next.group_id,
-				kind: "path-order",
-				evidence: {
-					path,
-					from_commit: prev.sha,
-					to_commit: next.sha,
-					from_commit_index: prev.commit_index,
-					to_commit_index: next.commit_index,
-				},
-			});
-		}
+		if (collapsed.length < 2) continue;
+
+		const first = collapsed[0]!;
+		const last = collapsed[collapsed.length - 1]!;
+		if (first.group_id === last.group_id) continue;
+
+		edges.push({
+			from: first.group_id,
+			to: last.group_id,
+			kind: "path-order",
+			evidence: {
+				path,
+				from_commit: first.sha,
+				to_commit: last.sha,
+				from_commit_index: first.commit_index,
+				to_commit_index: last.commit_index,
+			},
+		});
 	}
 }
 
@@ -135,10 +190,11 @@ function deduplicateEdges(edges: ConstraintEdge[]): ConstraintEdge[] {
 
 function topologicalSort(
 	groups: string[],
-	edges: ConstraintEdge[],
+	acyclicEdges: ConstraintEdge[],
 	deltas: DeltaEntry[],
 	ownership?: Map<string, string>,
 ): FeasibilityResult {
+	const edges = acyclicEdges;
 	const inDegree = new Map<string, number>();
 	const adjacency = new Map<string, string[]>();
 	const edgeMap = new Map<string, ConstraintEdge>();
@@ -183,9 +239,13 @@ function topologicalSort(
 	}
 
 	if (sorted.length === groups.length) {
+		const dependencyEdges = acyclicEdges
+			.filter((e) => e.kind === "dependency" || e.kind === "path-order")
+			.map((e) => ({ from: e.from, to: e.to }));
 		return {
 			feasible: true,
 			ordered_group_ids: sorted,
+			dependency_edges: dependencyEdges,
 		};
 	}
 
@@ -234,8 +294,8 @@ function tieBreaker(
 function findMinimalCycle(
 	allGroups: string[],
 	adjacency: Map<string, string[]>,
-	sorted: string[],
-	edgeMap: Map<string, ConstraintEdge>,
+	sorted: string[] = [],
+	edgeMap: Map<string, ConstraintEdge> = new Map(),
 ): CycleReport {
 	const inCycle = new Set(allGroups.filter((g) => !sorted.includes(g)));