newpr 0.6.5 → 1.0.0

package/src/stack/publish.ts

@@ -0,0 +1,96 @@
+import type { StackExecResult, StackPublishResult, BranchInfo, PrInfo } from "./types.ts";
+import type { PrMeta } from "../types/output.ts";
+
+export interface PublishInput {
+	repo_path: string;
+	exec_result: StackExecResult;
+	pr_meta: PrMeta;
+	base_branch: string;
+	owner: string;
+	repo: string;
+}
+
+export async function publishStack(input: PublishInput): Promise<StackPublishResult> {
+	const { repo_path, exec_result, pr_meta, base_branch, owner, repo } = input;
+	const ghRepo = `${owner}/${repo}`;
+
+	const branches: BranchInfo[] = [];
+	const prs: PrInfo[] = [];
+	const total = exec_result.group_commits.length;
+
+	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();
+
+		branches.push({
+			name: gc.branch_name,
+			pushed: pushResult.exitCode === 0,
+		});
+
+		if (pushResult.exitCode !== 0) {
+			continue;
+		}
+	}
+
+	for (let i = 0; i < exec_result.group_commits.length; i++) {
+		const gc = exec_result.group_commits[i];
+		if (!gc) continue;
+
+		const branchInfo = branches.find((b) => b.name === gc.branch_name);
+		if (!branchInfo?.pushed) continue;
+
+		const prBase = i === 0 ? base_branch : exec_result.group_commits[i - 1]?.branch_name;
+		if (!prBase) continue;
+
+		const order = i + 1;
+		const title = gc.pr_title
+			? `[${order}/${total}] ${gc.pr_title}`
+			: `[Stack ${order}/${total}] ${gc.group_id}`;
+
+		const body = buildPrBody(gc.group_id, order, total, exec_result, pr_meta);
+
+		const prResult = await Bun.$`gh pr create --repo ${ghRepo} --base ${prBase} --head ${gc.branch_name} --title ${title} --body ${body} --draft`.quiet().nothrow();
+
+		if (prResult.exitCode === 0) {
+			const prUrl = prResult.stdout.toString().trim();
+			const prNumberMatch = prUrl.match(/\/pull\/(\d+)/);
+
+			prs.push({
+				group_id: gc.group_id,
+				number: prNumberMatch ? parseInt(prNumberMatch[1]!, 10) : 0,
+				url: prUrl,
+				title,
+				base_branch: prBase,
+				head_branch: gc.branch_name,
+			});
+		} else {
+			const stderr = prResult.stderr.toString().trim();
+			console.error(`[publish] gh pr create failed for ${gc.group_id}: ${stderr}`);
+		}
+	}
+
+	return { branches, prs };
+}
+
+function buildPrBody(
+	groupId: string,
+	order: number,
+	total: number,
+	_execResult: StackExecResult,
+	prMeta: PrMeta,
+): string {
+	const prevPr = order > 1 ? `Previous: Stack ${order - 1}/${total}` : "Previous: (base branch)";
+	const nextPr = order < total ? `Next: Stack ${order + 1}/${total}` : "Next: (top of stack)";
+
+	const lines = [
+		`> This is part of a stacked PR chain created by [newpr](${prMeta.pr_url})`,
+		`>`,
+		`> **Stack order**: ${order}/${total}`,
+		`> **${prevPr}** | **${nextPr}**`,
+		``,
+		`## ${groupId}`,
+		``,
+		`*From PR #${prMeta.pr_number}: ${prMeta.pr_title}*`,
+	];
+
+	return lines.join("\n");
+}

package/src/stack/split.ts

@@ -0,0 +1,173 @@
+import type { LlmClient } from "../llm/client.ts";
+import type { FileGroup, GroupType } from "../types/output.ts";
+import type { StackWarning } from "./types.ts";
+
+export interface SplitResult {
+	groups: FileGroup[];
+	ownership: Map<string, string>;
+	warnings: StackWarning[];
+}
+
+interface SplitCandidate {
+	group: FileGroup;
+	files: string[];
+}
+
+const SPLIT_THRESHOLD = 8;
+
+function findSplitCandidates(
+	groups: FileGroup[],
+	ownership: Map<string, string>,
+): SplitCandidate[] {
+	const groupFiles = new Map<string, string[]>();
+	for (const [path, groupId] of ownership) {
+		const files = groupFiles.get(groupId) ?? [];
+		files.push(path);
+		groupFiles.set(groupId, files);
+	}
+
+	const candidates: SplitCandidate[] = [];
+	for (const group of groups) {
+		const files = groupFiles.get(group.name) ?? [];
+		if (files.length > SPLIT_THRESHOLD) {
+			candidates.push({ group, files });
+		}
+	}
+
+	return candidates;
+}
+
+export async function splitOversizedGroups(
+	llmClient: LlmClient,
+	groups: FileGroup[],
+	ownership: Map<string, string>,
+): Promise<SplitResult> {
+	const candidates = findSplitCandidates(groups, ownership);
+
+	if (candidates.length === 0) {
+		return { groups, ownership, warnings: [] };
+	}
+
+	const newGroups: FileGroup[] = [];
+	const newOwnership = new Map(ownership);
+	const warnings: StackWarning[] = [];
+
+	const unsplitGroupNames = new Set(groups.map((g) => g.name));
+	for (const c of candidates) {
+		unsplitGroupNames.delete(c.group.name);
+	}
+
+	for (const group of groups) {
+		if (unsplitGroupNames.has(group.name)) {
+			newGroups.push(group);
+		}
+	}
+
+	for (const candidate of candidates) {
+		const suggestedCount = Math.min(
+			Math.ceil(candidate.files.length / SPLIT_THRESHOLD),
+			4,
+		);
+
+		const system = `You split a large code change group into smaller, cohesive sub-groups for stacked PRs.
+
+Rules:
+1. Split into ${suggestedCount}-${suggestedCount + 1} sub-groups (aim for ${SPLIT_THRESHOLD} files or fewer each)
+2. Each sub-group must be a cohesive unit of change that can stand alone as a PR
+3. Group by logical purpose: shared utilities, specific feature area, tests, config, etc.
+4. Sub-group names must be concise (2-4 words), distinct from each other
+5. Every file from the input must appear in exactly one sub-group
+6. type must be one of: feature, refactor, bugfix, chore, docs, test, config
+
+Response format (JSON only, no markdown):
+[
+  {
+    "name": "sub-group name",
+    "type": "feature",
+    "description": "what this sub-group does",
+    "files": ["path/to/file1.ts", "path/to/file2.ts"]
+  }
+]`;
+
+		const user = `Original group: "${candidate.group.name}" (${candidate.group.type})
+Description: ${candidate.group.description}
+
+Files (${candidate.files.length}):
+${candidate.files.map((f) => `- ${f}`).join("\n")}
+
+Split this into ${suggestedCount}-${suggestedCount + 1} smaller, cohesive sub-groups.`;
+
+		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 Array<{
+				name: string;
+				type: string;
+				description: string;
+				files: string[];
+			}>;
+
+			if (!Array.isArray(parsed) || parsed.length < 2) {
+				newGroups.push(candidate.group);
+				continue;
+			}
+
+			const validTypes = new Set(["feature", "refactor", "bugfix", "chore", "docs", "test", "config"]);
+			const candidateFileSet = new Set(candidate.files);
+			const assignedFiles = new Set<string>();
+			const subGroups: FileGroup[] = [];
+
+			for (const sub of parsed) {
+				if (!sub.name || !sub.files || sub.files.length === 0) continue;
+
+				const validFiles = sub.files.filter((f) => candidateFileSet.has(f) && !assignedFiles.has(f));
+				if (validFiles.length === 0) continue;
+
+				for (const f of validFiles) assignedFiles.add(f);
+
+				const subGroup: FileGroup = {
+					name: sub.name,
+					type: (validTypes.has(sub.type) ? sub.type : candidate.group.type) as GroupType,
+					description: sub.description || candidate.group.description,
+					files: validFiles,
+				};
+				subGroups.push(subGroup);
+			}
+
+			const unassigned = candidate.files.filter((f) => !assignedFiles.has(f));
+			if (unassigned.length > 0 && subGroups.length > 0) {
+				subGroups[subGroups.length - 1]!.files.push(...unassigned);
+			}
+
+			if (subGroups.length < 2) {
+				newGroups.push(candidate.group);
+				continue;
+			}
+
+			for (const sg of subGroups) {
+				newGroups.push(sg);
+				for (const f of sg.files) {
+					newOwnership.set(f, sg.name);
+				}
+			}
+
+			warnings.push({
+				category: "grouping",
+				severity: "info",
+				title: `"${candidate.group.name}" split into ${subGroups.length} sub-groups`,
+				message: `Group had ${candidate.files.length} files — split for smaller, more focused PRs`,
+				details: subGroups.map((sg) => `"${sg.name}" (${sg.files.length} files)`),
+			});
+		} catch {
+			newGroups.push(candidate.group);
+			warnings.push({
+				category: "system",
+				severity: "warn",
+				title: `Failed to split "${candidate.group.name}"`,
+				message: "AI splitting failed — keeping original group intact",
+			});
+		}
+	}
+
+	return { groups: newGroups, ownership: newOwnership, warnings };
+}

package/src/stack/types.ts

@@ -0,0 +1,202 @@
+import type { FileGroup, GroupType } from "../types/output.ts";
+import type { PrCommit } from "../types/github.ts";
+
+// ============================================================================
+// Input Types
+// ============================================================================
+
+export interface StackInput {
+	session_id: string;
+	pr_number: number;
+	base_sha: string;
+	head_sha: string;
+	repo_path: string;
+	groups: FileGroup[];
+	commits: PrCommit[];
+	changed_files: string[];
+}
+
+// ============================================================================
+// Partition Types
+// ============================================================================
+
+export interface ReattributedFile {
+	path: string;
+	from_groups: string[];
+	to_group: string;
+	reason: string;
+}
+
+export interface PartitionResult {
+	ownership: Map<string, string>; // path -> groupId
+	reattributed: ReattributedFile[];
+	shared_foundation_group?: FileGroup;
+	warnings: string[];
+	structured_warnings: StackWarning[];
+}
+
+// ============================================================================
+// Delta Types
+// ============================================================================
+
+export type DeltaStatus = "A" | "M" | "D" | "R";
+
+export interface DeltaFileChange {
+	status: DeltaStatus;
+	path: string;
+	old_path?: string;
+	old_blob: string;
+	new_blob: string;
+	old_mode: string;
+	new_mode: string;
+}
+
+export interface DeltaEntry {
+	sha: string;
+	parent_sha: string;
+	author: string;
+	date: string;
+	message: string;
+	changes: DeltaFileChange[];
+}
+
+// ============================================================================
+// Feasibility Types
+// ============================================================================
+
+export type ConstraintKind = "dependency" | "path-order" | "unassigned" | "ambiguous";
+
+export interface ConstraintEvidence {
+	path: string;
+	from_commit?: string;
+	to_commit?: string;
+	from_commit_index?: number;
+	to_commit_index?: number;
+}
+
+export interface ConstraintEdge {
+	from: string; // groupId
+	to: string; // groupId
+	kind: ConstraintKind;
+	evidence?: ConstraintEvidence;
+}
+
+export interface CycleReport {
+	group_cycle: string[]; // [groupId, ...]
+	edge_cycle: ConstraintEdge[];
+}
+
+export interface FeasibilityResult {
+	feasible: boolean;
+	ordered_group_ids?: string[];
+	cycle?: CycleReport;
+	unassigned_paths?: Array<{ path: string; commits: string[] }>;
+	ambiguous_paths?: Array<{ path: string; groups: string[]; commits: string[] }>;
+}
+
+// ============================================================================
+// Plan Types
+// ============================================================================
+
+export interface StackGroupStats {
+	additions: number;
+	deletions: number;
+	files_added: number;
+	files_modified: number;
+	files_deleted: number;
+}
+
+export interface StackGroup {
+	id: string;
+	name: string;
+	type: GroupType;
+	description: string;
+	files: string[];
+	deps: string[]; // groupIds
+	order: number;
+	stats?: StackGroupStats;
+	pr_title?: string;
+}
+
+export interface StackPlan {
+	base_sha: string;
+	head_sha: string;
+	groups: StackGroup[];
+	expected_trees: Map<string, string>; // groupId -> treeSha
+}
+
+// ============================================================================
+// Execution Types
+// ============================================================================
+
+export interface GroupCommitInfo {
+	group_id: string;
+	commit_sha: string;
+	tree_sha: string;
+	branch_name: string;
+	pr_title?: string;
+}
+
+export interface StackExecResult {
+	run_id: string;
+	source_copy_branch: string;
+	group_commits: GroupCommitInfo[];
+	final_tree_sha: string;
+	verified: boolean;
+}
+
+// ============================================================================
+// Publication Types
+// ============================================================================
+
+export interface BranchInfo {
+	name: string;
+	pushed: boolean;
+}
+
+export interface PrInfo {
+	group_id: string;
+	number: number;
+	url: string;
+	title: string;
+	base_branch: string;
+	head_branch: string;
+}
+
+export interface StackPublishResult {
+	branches: BranchInfo[];
+	prs: PrInfo[];
+}
+
+// ============================================================================
+// Structured Warnings
+// ============================================================================
+
+export type StackWarningCategory =
+	| "assignment"
+	| "grouping"
+	| "coupling"
+	| "verification.scope"
+	| "verification.completeness"
+	| "system";
+
+export type StackWarningSeverity = "info" | "warn";
+
+export interface StackWarning {
+	category: StackWarningCategory;
+	severity: StackWarningSeverity;
+	title: string;
+	message: string;
+	details?: string[];
+}
+
+// ============================================================================
+// Progress Types
+// ============================================================================
+
+export interface StackProgress {
+	phase: string;
+	message: string;
+	current?: number;
+	total?: number;
+}

package/src/stack/verify.test.ts

@@ -0,0 +1,137 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createStackPlan } from "./plan.ts";
+import { executeStack } from "./execute.ts";
+import { extractDeltas } from "./delta.ts";
+import { verifyStack } from "./verify.ts";
+import type { FileGroup } from "../types/output.ts";
+
+let testRepoPath: string;
+let baseSha: string;
+let headSha: string;
+
+beforeAll(async () => {
+	testRepoPath = mkdtempSync(join(tmpdir(), "verify-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();
+
+	writeFileSync(join(testRepoPath, "README.md"), "initial\n");
+	await Bun.$`git -C ${testRepoPath} add README.md`.quiet();
+	await Bun.$`git -C ${testRepoPath} commit -m "Initial"`.quiet();
+
+	baseSha = (await Bun.$`git -C ${testRepoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+
+	mkdirSync(join(testRepoPath, "src"), { recursive: true });
+	writeFileSync(join(testRepoPath, "src", "auth.ts"), "export const auth = true;\n");
+	await Bun.$`git -C ${testRepoPath} add src/auth.ts`.quiet();
+	await Bun.$`git -C ${testRepoPath} commit -m "Add auth"`.quiet();
+
+	writeFileSync(join(testRepoPath, "src", "ui.tsx"), "export const UI = () => <div/>;\n");
+	await Bun.$`git -C ${testRepoPath} add src/ui.tsx`.quiet();
+	await Bun.$`git -C ${testRepoPath} commit -m "Add UI"`.quiet();
+
+	headSha = (await Bun.$`git -C ${testRepoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+});
+
+afterAll(() => {
+	if (testRepoPath) rmSync(testRepoPath, { recursive: true, force: true });
+});
+
+describe("verifyStack", () => {
+	test("valid stack passes all verification checks", 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,
+		});
+
+		const execResult = await executeStack({
+			repo_path: testRepoPath,
+			plan,
+			deltas,
+			ownership,
+			pr_author: { name: "Test", email: "t@t.com" },
+			pr_number: 1,
+			head_branch: "test-branch",
+		});
+
+		const verifyResult = await verifyStack({
+			repo_path: testRepoPath,
+			base_sha: baseSha,
+			head_sha: headSha,
+			exec_result: execResult,
+			ownership,
+		});
+
+		expect(verifyResult.verified).toBe(true);
+		expect(verifyResult.errors).toEqual([]);
+		expect(verifyResult.warnings).toBeDefined();
+	});
+
+	test("detects tree mismatch when final_tree_sha is wrong", 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,
+		});
+
+		const execResult = await executeStack({
+			repo_path: testRepoPath,
+			plan,
+			deltas,
+			ownership,
+			pr_author: { name: "Test", email: "t@t.com" },
+			pr_number: 2,
+			head_branch: "test-branch",
+		});
+
+		const tamperedResult = {
+			...execResult,
+			final_tree_sha: "0".repeat(40),
+		};
+
+		const verifyResult = await verifyStack({
+			repo_path: testRepoPath,
+			base_sha: baseSha,
+			head_sha: headSha,
+			exec_result: tamperedResult,
+			ownership,
+		});
+
+		expect(verifyResult.verified).toBe(false);
+		expect(verifyResult.errors.some((e) => e.includes("Final tree mismatch"))).toBe(true);
+		expect(verifyResult.warnings).toBeDefined();
+	});
+});