newpr 0.6.5 → 1.0.0

package/src/stack/feasibility.test.ts

@@ -0,0 +1,185 @@
+import { describe, test, expect } from "bun:test";
+import { checkFeasibility } from "./feasibility.ts";
+import type { DeltaEntry } from "./types.ts";
+
+function makeDelta(sha: string, parentSha: string, files: Array<{ status: "A" | "M" | "D"; path: string }>): DeltaEntry {
+	return {
+		sha,
+		parent_sha: parentSha,
+		author: "Test",
+		date: "2024-01-01",
+		message: `Commit ${sha}`,
+		changes: files.map((f) => ({
+			status: f.status,
+			path: f.path,
+			old_blob: "0".repeat(40),
+			new_blob: "1".repeat(40),
+			old_mode: f.status === "A" ? "000000" : "100644",
+			new_mode: f.status === "D" ? "000000" : "100644",
+		})),
+	};
+}
+
+describe("checkFeasibility", () => {
+	test("monotonic sequence (A→B→C) is feasible with correct order", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "A", path: "a.ts" }]),
+			makeDelta("c2", "c1", [{ status: "A", path: "b.ts" }]),
+			makeDelta("c3", "c2", [{ status: "A", path: "c.ts" }]),
+		];
+
+		const ownership = new Map([
+			["a.ts", "group-a"],
+			["b.ts", "group-b"],
+			["c.ts", "group-c"],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership });
+
+		expect(result.feasible).toBe(true);
+		expect(result.ordered_group_ids).toBeDefined();
+	});
+
+	test("non-monotonic (A→B→A) is infeasible with cycle report", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "M", path: "shared.ts" }]),
+			makeDelta("c2", "c1", [{ status: "M", path: "shared.ts" }]),
+			makeDelta("c3", "c2", [{ status: "M", path: "shared.ts" }]),
+		];
+
+		const ownership = new Map([
+			["shared.ts", "group-a"],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership });
+		expect(result.feasible).toBe(true);
+	});
+
+	test("same-group edits across commits are monotonic → feasible", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [
+				{ status: "M", path: "file-a.ts" },
+				{ status: "M", path: "file-b.ts" },
+			]),
+			makeDelta("c2", "c1", [
+				{ status: "M", path: "file-b.ts" },
+				{ status: "M", path: "file-a.ts" },
+			]),
+		];
+
+		const ownership = new Map([
+			["file-a.ts", "group-a"],
+			["file-b.ts", "group-b"],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership });
+		expect(result.feasible).toBe(true);
+	});
+
+	test("declared deps creating cycle → infeasible", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "A", path: "a.ts" }]),
+			makeDelta("c2", "c1", [{ 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(false);
+		expect(result.cycle).toBeDefined();
+		expect(result.cycle?.group_cycle.length).toBeGreaterThan(0);
+	});
+
+	test("single file in one group → no edges, feasible", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "A", path: "a.ts" }]),
+		];
+
+		const ownership = new Map([["a.ts", "group-a"]]);
+
+		const result = checkFeasibility({ deltas, ownership });
+
+		expect(result.feasible).toBe(true);
+		expect(result.ordered_group_ids).toEqual(["group-a"]);
+	});
+
+	test("empty input → feasible", () => {
+		const result = checkFeasibility({
+			deltas: [],
+			ownership: new Map(),
+		});
+
+		expect(result.feasible).toBe(true);
+		expect(result.ordered_group_ids).toEqual([]);
+	});
+
+	test("per-file monotonic edits across commits → feasible", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "M", path: "file-x.ts" }]),
+			makeDelta("c2", "c1", [{ status: "M", path: "file-y.ts" }]),
+			makeDelta("c3", "c2", [{ status: "M", path: "file-x.ts" }]),
+			makeDelta("c4", "c3", [{ status: "M", path: "file-y.ts" }]),
+		];
+
+		const ownership = new Map([
+			["file-x.ts", "group-a"],
+			["file-y.ts", "group-b"],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership });
+		expect(result.feasible).toBe(true);
+	});
+
+	test("mutual declared deps create cycle → infeasible", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "A", path: "a.ts" }]),
+			makeDelta("c2", "c1", [{ 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(false);
+		expect(result.cycle).toBeDefined();
+	});
+
+	test("declared deps without cycle → feasible with correct order", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "A", path: "a.ts" }]),
+			makeDelta("c2", "c1", [{ status: "A", path: "b.ts" }]),
+		];
+
+		const ownership = new Map([
+			["a.ts", "group-a"],
+			["b.ts", "group-b"],
+		]);
+
+		const declaredDeps = new Map([
+			["group-b", ["group-a"]],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
+
+		expect(result.feasible).toBe(true);
+		expect(result.ordered_group_ids).toBeDefined();
+		const order = result.ordered_group_ids!;
+		expect(order.indexOf("group-a")).toBeLessThan(order.indexOf("group-b"));
+	});
+});

package/src/stack/feasibility.ts

@@ -0,0 +1,286 @@
+import type {
+	DeltaEntry,
+	ConstraintEdge,
+	CycleReport,
+	FeasibilityResult,
+} from "./types.ts";
+
+interface FeasibilityInput {
+	deltas: DeltaEntry[];
+	ownership: Map<string, string>;
+	declared_deps?: Map<string, string[]>;
+}
+
+export function checkFeasibility(input: FeasibilityInput): FeasibilityResult {
+	const { deltas, ownership, declared_deps } = input;
+
+	const allGroups = new Set<string>(ownership.values());
+	if (allGroups.size <= 1) {
+		return {
+			feasible: true,
+			ordered_group_ids: Array.from(allGroups),
+		};
+	}
+
+	const edges: ConstraintEdge[] = [];
+
+	addPathOrderEdges(deltas, ownership, edges);
+	if (declared_deps) {
+		addDeclaredDepEdges(declared_deps, allGroups, edges);
+	}
+
+	const deduped = deduplicateEdges(edges);
+	const result = topologicalSort(Array.from(allGroups), deduped, deltas);
+
+	return result;
+}
+
+function addPathOrderEdges(
+	deltas: DeltaEntry[],
+	ownership: Map<string, string>,
+	edges: ConstraintEdge[],
+): void {
+	const pathEditSequences = new Map<string, Array<{ commit_index: number; group_id: string; sha: string }>>();
+
+	for (let commitIdx = 0; commitIdx < deltas.length; commitIdx++) {
+		const delta = deltas[commitIdx];
+		if (!delta) continue;
+
+		for (const change of delta.changes) {
+			const path = change.path;
+			const groupId = ownership.get(path);
+			if (!groupId) continue;
+
+			let seq = pathEditSequences.get(path);
+			if (!seq) {
+				seq = [];
+				pathEditSequences.set(path, seq);
+			}
+			seq.push({ commit_index: commitIdx, group_id: groupId, sha: delta.sha });
+		}
+	}
+
+	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,
+				},
+			});
+		}
+	}
+}
+
+function collapseConsecutiveDuplicates<T extends { group_id: string }>(
+	seq: T[],
+): T[] {
+	const result: T[] = [];
+	for (const item of seq) {
+		const last = result[result.length - 1];
+		if (!last || last.group_id !== item.group_id) {
+			result.push(item);
+		}
+	}
+	return result;
+}
+
+function addDeclaredDepEdges(
+	declaredDeps: Map<string, string[]>,
+	allGroups: Set<string>,
+	edges: ConstraintEdge[],
+): void {
+	for (const [groupId, deps] of declaredDeps) {
+		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: "dependency",
+			});
+		}
+	}
+}
+
+function deduplicateEdges(edges: ConstraintEdge[]): ConstraintEdge[] {
+	const seen = new Set<string>();
+	const result: ConstraintEdge[] = [];
+
+	for (const edge of edges) {
+		const key = `${edge.from}→${edge.to}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(edge);
+	}
+
+	return result;
+}
+
+function topologicalSort(
+	groups: string[],
+	edges: ConstraintEdge[],
+	deltas: DeltaEntry[],
+): FeasibilityResult {
+	const inDegree = new Map<string, number>();
+	const adjacency = new Map<string, string[]>();
+	const edgeMap = new Map<string, ConstraintEdge>();
+
+	for (const g of groups) {
+		inDegree.set(g, 0);
+		adjacency.set(g, []);
+	}
+
+	for (const edge of edges) {
+		const neighbors = adjacency.get(edge.from);
+		if (neighbors) {
+			neighbors.push(edge.to);
+		}
+		inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+		edgeMap.set(`${edge.from}→${edge.to}`, edge);
+	}
+
+	const firstCommitDate = buildFirstCommitDateMap(groups, deltas);
+
+	const queue: string[] = [];
+	for (const [g, deg] of inDegree) {
+		if (deg === 0) queue.push(g);
+	}
+	queue.sort((a, b) => tieBreaker(a, b, firstCommitDate));
+
+	const sorted: string[] = [];
+
+	while (queue.length > 0) {
+		queue.sort((a, b) => tieBreaker(a, b, firstCommitDate));
+		const node = queue.shift()!;
+		sorted.push(node);
+
+		const neighbors = adjacency.get(node) ?? [];
+		for (const neighbor of neighbors) {
+			const deg = (inDegree.get(neighbor) ?? 1) - 1;
+			inDegree.set(neighbor, deg);
+			if (deg === 0) {
+				queue.push(neighbor);
+			}
+		}
+	}
+
+	if (sorted.length === groups.length) {
+		return {
+			feasible: true,
+			ordered_group_ids: sorted,
+		};
+	}
+
+	const cycle = findMinimalCycle(groups, adjacency, sorted, edgeMap);
+
+	return {
+		feasible: false,
+		ordered_group_ids: undefined,
+		cycle,
+	};
+}
+
+function buildFirstCommitDateMap(
+	groups: string[],
+	deltas: DeltaEntry[],
+): Map<string, string> {
+	const result = new Map<string, string>();
+	for (const g of groups) {
+		result.set(g, "9999");
+	}
+	for (const delta of deltas) {
+		for (const change of delta.changes) {
+			const g = change.path;
+			if (result.has(g)) {
+				const current = result.get(g);
+				if (!current || delta.date < current) {
+					result.set(g, delta.date);
+				}
+			}
+		}
+	}
+	return result;
+}
+
+function tieBreaker(
+	a: string,
+	b: string,
+	firstCommitDate: Map<string, string>,
+): number {
+	const dateA = firstCommitDate.get(a) ?? "9999";
+	const dateB = firstCommitDate.get(b) ?? "9999";
+	if (dateA !== dateB) return dateA < dateB ? -1 : 1;
+	return a.localeCompare(b);
+}
+
+function findMinimalCycle(
+	allGroups: string[],
+	adjacency: Map<string, string[]>,
+	sorted: string[],
+	edgeMap: Map<string, ConstraintEdge>,
+): CycleReport {
+	const inCycle = new Set(allGroups.filter((g) => !sorted.includes(g)));
+
+	if (inCycle.size === 0) {
+		return { group_cycle: [], edge_cycle: [] };
+	}
+
+	const start = Array.from(inCycle)[0]!;
+	const visited = new Map<string, string>();
+	const bfsQueue: string[] = [start];
+	visited.set(start, "");
+
+	while (bfsQueue.length > 0) {
+		const current = bfsQueue.shift()!;
+		const neighbors = adjacency.get(current) ?? [];
+
+		for (const neighbor of neighbors) {
+			if (!inCycle.has(neighbor)) continue;
+
+			if (neighbor === start && visited.size > 1) {
+				const cycle: string[] = [start];
+				let backtrack = current;
+				while (backtrack !== start && backtrack !== "") {
+					cycle.unshift(backtrack);
+					backtrack = visited.get(backtrack) ?? "";
+				}
+				cycle.push(start);
+
+				const edgeCycle: ConstraintEdge[] = [];
+				for (let i = 0; i < cycle.length - 1; i++) {
+					const edge = edgeMap.get(`${cycle[i]}→${cycle[i + 1]}`);
+					if (edge) edgeCycle.push(edge);
+				}
+
+				return { group_cycle: cycle, edge_cycle: edgeCycle };
+			}
+
+			if (!visited.has(neighbor)) {
+				visited.set(neighbor, current);
+				bfsQueue.push(neighbor);
+			}
+		}
+	}
+
+	return {
+		group_cycle: Array.from(inCycle),
+		edge_cycle: [],
+	};
+}