newpr 1.0.23 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "description": "AI-powered large PR review tool - understand PRs with 1000+ lines of changes",
   "module": "src/cli/index.ts",
   "type": "module",

package/src/stack/import-deps.test.ts

@@ -0,0 +1,254 @@
+import { describe, test, expect, afterAll } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { analyzeImportDependencies } from "./import-deps.ts";
+
+const tmpDirs: string[] = [];
+
+function makeTmpRepo(): string {
+	const dir = mkdtempSync(join(tmpdir(), "import-deps-"));
+	tmpDirs.push(dir);
+	return dir;
+}
+
+afterAll(() => {
+	for (const dir of tmpDirs) {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+async function initRepo(path: string): Promise<void> {
+	await Bun.$`git init ${path}`.quiet();
+	await Bun.$`git -C ${path} config user.name "Test"`.quiet();
+	await Bun.$`git -C ${path} config user.email "test@test.com"`.quiet();
+}
+
+async function commitFiles(repoPath: string, files: Record<string, string>, msg: string): Promise<string> {
+	for (const [filePath, content] of Object.entries(files)) {
+		const fullPath = join(repoPath, filePath);
+		const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+		mkdirSync(dir, { recursive: true });
+		writeFileSync(fullPath, content);
+	}
+	await Bun.$`git -C ${repoPath} add -A`.quiet();
+	await Bun.$`git -C ${repoPath} commit -m ${msg}`.quiet();
+	return (await Bun.$`git -C ${repoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+}
+
+describe("analyzeImportDependencies", () => {
+	test("detects single-line imports between changed files", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/utils/helper.ts": "export function greet() { return 'hi'; }",
+			"src/components/button.ts": "import { greet } from '../utils/helper';\nexport const btn = greet();",
+		}, "add files");
+
+		const ownership = new Map([
+			["src/utils/helper.ts", "Utils"],
+			["src/components/button.ts", "UI"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/components/button.ts")).toContain("src/utils/helper.ts");
+		expect(result.groupDeps.get("UI")).toContain("Utils");
+	});
+
+	test("detects multiline named imports", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/types.ts": "export interface Foo {}\nexport interface Bar {}\nexport interface Baz {}",
+			"src/consumer.ts": [
+				"import {",
+				"  Foo,",
+				"  Bar,",
+				"  Baz,",
+				"} from './types';",
+				"",
+				"const x: Foo = {} as Foo;",
+			].join("\n"),
+		}, "multiline import");
+
+		const ownership = new Map([
+			["src/types.ts", "Types"],
+			["src/consumer.ts", "Feature"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/consumer.ts")).toContain("src/types.ts");
+		expect(result.groupDeps.get("Feature")).toContain("Types");
+	});
+
+	test("detects side-effect imports", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/setup.ts": "globalThis.__initialized = true;",
+			"src/app.ts": "import './setup';\nconsole.log('app');",
+		}, "side-effect");
+
+		const ownership = new Map([
+			["src/setup.ts", "Setup"],
+			["src/app.ts", "App"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/app.ts")).toContain("src/setup.ts");
+		expect(result.groupDeps.get("App")).toContain("Setup");
+	});
+
+	test("detects dynamic imports", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/lazy.ts": "export const LazyComponent = () => 'lazy';",
+			"src/loader.ts": "export async function load() { const mod = await import('./lazy'); return mod; }",
+		}, "dynamic import");
+
+		const ownership = new Map([
+			["src/lazy.ts", "Lazy"],
+			["src/loader.ts", "Loader"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/loader.ts")).toContain("src/lazy.ts");
+		expect(result.groupDeps.get("Loader")).toContain("Lazy");
+	});
+
+	test("detects re-exports (export from)", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/internal.ts": "export const SECRET = 42;",
+			"src/index.ts": "export { SECRET } from './internal';",
+		}, "re-export");
+
+		const ownership = new Map([
+			["src/internal.ts", "Core"],
+			["src/index.ts", "Public"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/index.ts")).toContain("src/internal.ts");
+		expect(result.groupDeps.get("Public")).toContain("Core");
+	});
+
+	test("detects type-only imports", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/types.ts": "export interface Config { key: string; }",
+			"src/use-config.ts": "import type { Config } from './types';\nconst c: Config = { key: 'x' };",
+		}, "type import");
+
+		const ownership = new Map([
+			["src/types.ts", "Types"],
+			["src/use-config.ts", "Feature"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/use-config.ts")).toContain("src/types.ts");
+		expect(result.groupDeps.get("Feature")).toContain("Types");
+	});
+
+	test("resolves extensionless imports to .ts files", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/utils.ts": "export const add = (a: number, b: number) => a + b;",
+			"src/main.ts": "import { add } from './utils';\nconsole.log(add(1, 2));",
+		}, "extensionless");
+
+		const ownership = new Map([
+			["src/utils.ts", "Utils"],
+			["src/main.ts", "Main"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/main.ts")).toContain("src/utils.ts");
+	});
+
+	test("resolves index file imports", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/lib/index.ts": "export { default as Btn } from './button';",
+			"src/lib/button.ts": "export default function Btn() { return 'btn'; }",
+			"src/app.ts": "import { Btn } from './lib';\nconsole.log(Btn());",
+		}, "index import");
+
+		const ownership = new Map([
+			["src/lib/index.ts", "Lib"],
+			["src/lib/button.ts", "Lib"],
+			["src/app.ts", "App"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/app.ts")).toContain("src/lib/index.ts");
+		expect(result.groupDeps.get("App")).toContain("Lib");
+	});
+
+	test("ignores non-relative imports", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/app.ts": "import React from 'react';\nimport { useState } from 'react';\nconsole.log(React);",
+		}, "npm imports");
+
+		const ownership = new Map([["src/app.ts", "App"]]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.size).toBe(0);
+		expect(result.groupDeps.size).toBe(0);
+	});
+
+	test("does not create self-group dependencies", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/a.ts": "export const A = 1;",
+			"src/b.ts": "import { A } from './a';\nexport const B = A + 1;",
+		}, "same group");
+
+		const ownership = new Map([
+			["src/a.ts", "Feature"],
+			["src/b.ts", "Feature"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/b.ts")).toContain("src/a.ts");
+		expect(result.groupDeps.size).toBe(0);
+	});
+});

package/src/stack/import-deps.ts

@@ -1,21 +1,77 @@
-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",
 ]);
 
+const EXT_TO_LOADER: Record<string, "ts" | "tsx" | "js" | "jsx"> = {
+	".ts": "ts",
+	".tsx": "tsx",
+	".js": "js",
+	".jsx": "jsx",
+	".mjs": "js",
+	".cjs": "js",
+};
+
+const transpilerCache = new Map<string, InstanceType<typeof Bun.Transpiler>>();
+
+function getTranspiler(loader: "ts" | "tsx" | "js" | "jsx"): InstanceType<typeof Bun.Transpiler> {
+	let t = transpilerCache.get(loader);
+	if (!t) {
+		t = new Bun.Transpiler({ loader });
+		transpilerCache.set(loader, t);
+	}
+	return t;
+}
+
 function isRelativeImport(specifier: string): boolean {
 	return specifier.startsWith("./") || specifier.startsWith("../");
 }
 
-function extractImports(source: string): string[] {
+function fileExt(f: string): string {
+	const dot = f.lastIndexOf(".");
+	return dot >= 0 ? f.slice(dot) : "";
+}
+
+// scanImports skips `import type` — this catches them for dependency tracking
+const TYPE_IMPORT_RE = /import\s+type\s+(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/gs;
+
+function extractImports(source: string, filePath: string): string[] {
+	const ext = fileExt(filePath);
+	const loader = EXT_TO_LOADER[ext];
+	if (!loader) return [];
+
+	try {
+		const transpiler = getTranspiler(loader);
+		const scanned = transpiler.scanImports(source);
+		const results = new Set(
+			scanned.map((imp) => imp.path).filter(isRelativeImport),
+		);
+
+		TYPE_IMPORT_RE.lastIndex = 0;
+		let m: RegExpExecArray | null;
+		while ((m = TYPE_IMPORT_RE.exec(source)) !== null) {
+			if (m[1] && isRelativeImport(m[1])) results.add(m[1]);
+		}
+
+		return Array.from(results);
+	} catch {
+		return extractImportsFallback(source);
+	}
+}
+
+const FALLBACK_PATTERNS: RegExp[] = [
+	// import/export ... from '...' (multiline-safe via [\s\S])
+	/(?:import|export)\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]/g,
+	// side-effect: import './foo'
+	/import\s+['"]([^'"]+)['"]/g,
+	// dynamic: import('./foo')
+	/import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+	// require('./foo')
+	/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+];
+
+function extractImportsFallback(source: string): string[] {
 	const imports = new Set<string>();
-	for (const re of IMPORT_PATTERNS) {
+	for (const re of FALLBACK_PATTERNS) {
 		re.lastIndex = 0;
 		let match: RegExpExecArray | null;
 		while ((match = re.exec(source)) !== null) {
@@ -81,18 +137,13 @@ export async function analyzeImportDependencies(
 	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)));
+	const analyzable = changedFiles.filter((f) => ANALYZABLE_EXTENSIONS.has(fileExt(f)));
 
 	await Promise.all(analyzable.map(async (filePath) => {
 		const source = await readFileFromGit(repoPath, headSha, filePath);
 		if (!source) return;
 
-		const rawImports = extractImports(source);
+		const rawImports = extractImports(source, filePath);
 		const resolved: string[] = [];
 
 		for (const specifier of rawImports) {
@@ -124,7 +175,9 @@ export async function analyzeImportDependencies(
 
 	const groupDepsMap = new Map<string, string[]>();
 	for (const [group, deps] of groupDeps) {
-		groupDepsMap.set(group, Array.from(deps));
+		if (deps.size > 0) {
+			groupDepsMap.set(group, Array.from(deps));
+		}
 	}
 
 	return { fileDeps, groupDeps: groupDepsMap };

package/src/web/client/components/Markdown.tsx

@@ -134,8 +134,9 @@ function isLineLabelCandidate(text: string): boolean {
 	if (trimmed.length > MAX_LINE_LABEL_LENGTH) return false;
 	if (trimmed.includes("\n")) return false;
 	if (trimmed.includes("[[")) return false;
-	const backtickCount = (trimmed.match(/`/g) ?? []).length;
-	if (backtickCount % 2 !== 0) return false;
+	// No backtick parity check — inlineMarkdownToHtml handles unpaired
+	// backticks gracefully (regex simply won't match them, they render as
+	// literal characters after HTML-escaping).
 	return true;
 }
 
@@ -171,13 +172,13 @@ function replaceLineAnchors(text: string): string {
 				else if (text[end] === ")") depth--;
 				end++;
 			}
-			if (depth === 0) {
-				const candidate = text.slice(afterClose + 1, end - 1);
-				if (isLineLabelCandidate(candidate)) {
-					label = candidate;
-					afterClose = end;
-				}
+		if (depth === 0) {
+			const candidate = text.slice(afterClose + 1, end - 1);
+			if (isLineLabelCandidate(candidate)) {
+				label = candidate;
 			}
+			afterClose = end;
+		}
 		}
 
 		const encoded = encodeURIComponent(id);