newpr 1.0.20 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "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/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,
+			},
+		});
 	}
 }
 
@@ -234,8 +289,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)));
 

package/src/stack/import-deps.ts

@@ -0,0 +1,131 @@
+const IMPORT_PATTERNS: RegExp[] = [
+	/^\s*import\s+.*?\s+from\s+['"]([^'"]+)['"]/gm,
+	/^\s*export\s+.*?\s+from\s+['"]([^'"]+)['"]/gm,
+	/^\s*import\s*\(\s*['"]([^'"]+)['"]\s*\)/gm,
+	/^\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm,
+];
+
+const ANALYZABLE_EXTENSIONS = new Set([
+	".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+]);
+
+function isRelativeImport(specifier: string): boolean {
+	return specifier.startsWith("./") || specifier.startsWith("../");
+}
+
+function extractImports(source: string): string[] {
+	const imports = new Set<string>();
+	for (const re of IMPORT_PATTERNS) {
+		re.lastIndex = 0;
+		let match: RegExpExecArray | null;
+		while ((match = re.exec(source)) !== null) {
+			const specifier = match[1];
+			if (specifier && isRelativeImport(specifier)) {
+				imports.add(specifier);
+			}
+		}
+	}
+	return Array.from(imports);
+}
+
+function resolveRelative(fromFile: string, specifier: string): string {
+	const parts = fromFile.split("/");
+	parts.pop();
+	const segments = specifier.split("/");
+	for (const seg of segments) {
+		if (seg === "..") {
+			parts.pop();
+		} else if (seg !== ".") {
+			parts.push(seg);
+		}
+	}
+	return parts.join("/");
+}
+
+function resolveToExistingFile(
+	candidate: string,
+	fileSet: Set<string>,
+): string | null {
+	if (fileSet.has(candidate)) return candidate;
+
+	for (const ext of ANALYZABLE_EXTENSIONS) {
+		const withExt = `${candidate}${ext}`;
+		if (fileSet.has(withExt)) return withExt;
+	}
+
+	for (const indexFile of ["index.ts", "index.tsx", "index.js"]) {
+		const asDir = `${candidate}/${indexFile}`;
+		if (fileSet.has(asDir)) return asDir;
+	}
+
+	return null;
+}
+
+async function readFileFromGit(repoPath: string, sha: string, filePath: string): Promise<string | null> {
+	const result = await Bun.$`git -C ${repoPath} show ${sha}:${filePath}`.quiet().nothrow();
+	if (result.exitCode !== 0) return null;
+	return result.stdout.toString();
+}
+
+export interface ImportDepResult {
+	fileDeps: Map<string, string[]>;
+	groupDeps: Map<string, string[]>;
+}
+
+export async function analyzeImportDependencies(
+	repoPath: string,
+	headSha: string,
+	changedFiles: string[],
+	ownership: Map<string, string>,
+): Promise<ImportDepResult> {
+	const fileSet = new Set(changedFiles);
+	const fileDeps = new Map<string, string[]>();
+
+	const ext = (f: string) => {
+		const dot = f.lastIndexOf(".");
+		return dot >= 0 ? f.slice(dot) : "";
+	};
+
+	const analyzable = changedFiles.filter((f) => ANALYZABLE_EXTENSIONS.has(ext(f)));
+
+	await Promise.all(analyzable.map(async (filePath) => {
+		const source = await readFileFromGit(repoPath, headSha, filePath);
+		if (!source) return;
+
+		const rawImports = extractImports(source);
+		const resolved: string[] = [];
+
+		for (const specifier of rawImports) {
+			const candidate = resolveRelative(filePath, specifier);
+			const existing = resolveToExistingFile(candidate, fileSet);
+			if (existing && existing !== filePath) {
+				resolved.push(existing);
+			}
+		}
+
+		if (resolved.length > 0) {
+			fileDeps.set(filePath, resolved);
+		}
+	}));
+
+	const groupDeps = new Map<string, Set<string>>();
+	for (const [fromFile, toFiles] of fileDeps) {
+		const fromGroup = ownership.get(fromFile);
+		if (!fromGroup) continue;
+
+		if (!groupDeps.has(fromGroup)) groupDeps.set(fromGroup, new Set());
+
+		for (const toFile of toFiles) {
+			const toGroup = ownership.get(toFile);
+			if (!toGroup || toGroup === fromGroup) continue;
+			groupDeps.get(fromGroup)!.add(toGroup);
+		}
+	}
+
+	const groupDepsMap = new Map<string, string[]>();
+	for (const [group, deps] of groupDeps) {
+		groupDepsMap.set(group, Array.from(deps));
+	}
+
+	return { fileDeps, groupDeps: groupDepsMap };
+}

package/src/stack/integration.test.ts

@@ -260,7 +260,7 @@ describe("integration: full stacking pipeline", () => {
 			]),
 		});
 
-		expect(feasibility.feasible).toBe(false);
-		expect(feasibility.cycle).toBeDefined();
+		expect(feasibility.feasible).toBe(true);
+		expect(feasibility.ordered_group_ids).toHaveLength(2);
 	});
 });