newpr 0.1.3 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "AI-powered large PR review tool - understand PRs with 1000+ lines of changes",
   "module": "src/cli/index.ts",
   "type": "module",
@@ -61,16 +61,26 @@
     "@radix-ui/react-slot": "^1.2.4",
     "@radix-ui/react-tabs": "^1.1.13",
     "@tailwindcss/cli": "^4.1.18",
+    "@tiptap/extension-mention": "^3.19.0",
+    "@tiptap/extension-placeholder": "^3.19.0",
+    "@tiptap/pm": "^3.19.0",
+    "@tiptap/react": "^3.19.0",
+    "@tiptap/starter-kit": "^3.19.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "ink": "6.6.0",
     "ink-spinner": "5.0.0",
     "ink-text-input": "6.0.0",
+    "katex": "^0.16.28",
     "lucide-react": "^0.567.0",
     "react": "19.1.0",
     "react-dom": "19.1.0",
     "react-markdown": "^10.1.0",
+    "rehype-katex": "^7.0.1",
+    "rehype-raw": "^7.0.0",
     "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
+    "shiki": "^3.22.0",
     "tailwind-merge": "^3.4.1",
     "tailwindcss": "^4.1.18",
     "tailwindcss-animate": "^1.0.7"

package/src/analyzer/pipeline.ts

@@ -6,7 +6,7 @@ import type { ExplorationResult } from "../workspace/types.ts";
 import type { AgentToolName } from "../workspace/types.ts";
 import { parseDiff } from "../diff/parser.ts";
 import { chunkDiff } from "../diff/chunker.ts";
-import { fetchPrData } from "../github/fetch-pr.ts";
+import { fetchPrData, fetchPrComments } from "../github/fetch-pr.ts";
 import { fetchPrDiff } from "../github/fetch-diff.ts";
 import { createLlmClient, type LlmClient, type LlmResponse } from "../llm/client.ts";
 import {
@@ -50,6 +50,7 @@ interface PipelineOptions {
 	token: string;
 	config: NewprConfig;
 	onProgress?: ProgressCallback;
+	onFilePatches?: (patches: Record<string, string>) => void;
 	noClone?: boolean;
 	preferredAgent?: AgentToolName;
 }
@@ -84,25 +85,25 @@ async function runExploration(
 ): Promise<ExplorationResult> {
 	const agent = await requireAgent(preferredAgent);
 
-	onProgress?.({ stage: "cloning", message: `${pr.owner}/${pr.repo}` });
+	onProgress?.({ stage: "cloning", message: `Cloning ${pr.owner}/${pr.repo}...` });
 	const bareRepoPath = await ensureRepo(pr.owner, pr.repo, token, (msg) => {
-		onProgress?.({ stage: "cloning", message: msg });
+		onProgress?.({ stage: "cloning", message: `📦 ${msg}` });
 	});
-	onProgress?.({ stage: "cloning", message: `${pr.owner}/${pr.repo} ready` });
+	onProgress?.({ stage: "cloning", message: `📦 ${pr.owner}/${pr.repo} cached` });
 
-	onProgress?.({ stage: "checkout", message: `${baseBranch} ← PR #${pr.number}` });
+	onProgress?.({ stage: "checkout", message: `🌿 Preparing worktrees: ${baseBranch} ← PR #${pr.number}` });
 	const worktrees = await createWorktrees(
 		bareRepoPath, baseBranch, pr.number, pr.owner, pr.repo,
-		(msg) => onProgress?.({ stage: "checkout", message: msg }),
+		(msg) => onProgress?.({ stage: "checkout", message: `🌿 ${msg}` }),
 	);
-	onProgress?.({ stage: "checkout", message: `${baseBranch} ← PR #${pr.number} worktrees ready` });
+	onProgress?.({ stage: "checkout", message: `🌿 Worktrees ready: ${baseBranch} ← PR #${pr.number}` });
 
-	onProgress?.({ stage: "exploring", message: `${agent.name}: analyzing ${changedFiles.length} files...` });
+	onProgress?.({ stage: "exploring", message: `🤖 ${agent.name}: exploring ${changedFiles.length} changed files...` });
 	const exploration = await exploreCodebase(
 		agent, worktrees.headPath, changedFiles, prTitle, rawDiff,
 		(msg, current, total) => onProgress?.({ stage: "exploring", message: msg, current, total }),
 	);
-	onProgress?.({ stage: "exploring", message: `${agent.name}: exploration complete` });
+	onProgress?.({ stage: "exploring", message: `🤖 ${agent.name}: exploration complete` });
 
 	await cleanupWorktrees(bareRepoPath, pr.number, pr.owner, pr.repo).catch(() => {});
 
@@ -158,12 +159,13 @@ export async function analyzePr(options: PipelineOptions): Promise<NewprOutput>
 		timeout: config.timeout,
 	});
 
-	progress({ stage: "fetching", message: "Fetching PR data and diff..." });
-	const [prData, rawDiff] = await Promise.all([
+	progress({ stage: "fetching", message: "Fetching PR data, diff, and discussion..." });
+	const [prData, rawDiff, prComments] = await Promise.all([
 		fetchPrData(pr, token),
 		fetchPrDiff(pr, token),
+		fetchPrComments(pr, token).catch(() => []),
 	]);
-	progress({ stage: "fetching", message: `#${prData.number} "${prData.title}" by ${prData.author} · +${prData.additions} −${prData.deletions}` });
+	progress({ stage: "fetching", message: `#${prData.number} "${prData.title}" by ${prData.author} · +${prData.additions} −${prData.deletions} · ${prComments.length} comments`, pr_title: prData.title, pr_number: prData.number });
 
 	progress({ stage: "parsing", message: "Parsing diff..." });
 	const parsed = parseDiff(rawDiff);
@@ -175,6 +177,15 @@ export async function analyzePr(options: PipelineOptions): Promise<NewprOutput>
 	const totalDel = chunks.reduce((s, c) => s + c.deletions, 0);
 	progress({ stage: "parsing", message: `${chunks.length} files · +${totalAdd} −${totalDel}${wasTruncated ? ` (${allChunks.length - config.max_files} skipped)` : ""}` });
 
+	const changedFilesSet = new Set(changedFiles);
+	const filePatches: Record<string, string> = {};
+	for (const fileDiff of parsed.files) {
+		if (changedFilesSet.has(fileDiff.path)) {
+			filePatches[fileDiff.path] = fileDiff.raw;
+		}
+	}
+	options.onFilePatches?.(filePatches);
+
 	let exploration: ExplorationResult | null = null;
 	if (!noClone) {
 		exploration = await tryExploreCodebase(
@@ -183,7 +194,12 @@ export async function analyzePr(options: PipelineOptions): Promise<NewprOutput>
 		);
 	}
 
-	const promptCtx: PromptContext = { commits: prData.commits, language: config.language };
+	const promptCtx: PromptContext = {
+		commits: prData.commits,
+		language: config.language,
+		prBody: prData.body,
+		discussion: prComments.map((c) => ({ author: c.author, body: c.body })),
+	};
 	const enrichedTag = exploration ? " + codebase context" : "";
 
 	progress({
@@ -243,9 +259,13 @@ export async function analyzePr(options: PipelineOptions): Promise<NewprOutput>
 	progress({ stage: "summarizing", message: `${summary.risk_level} risk · ${summary.purpose.slice(0, 60)}` });
 
 	progress({ stage: "narrating", message: `Writing narrative${enrichedTag}...` });
+	const fileDiffs = chunks.slice(0, 30).map((c) => ({
+		path: c.file_path,
+		diff: c.diff_content.length > 3000 ? `${c.diff_content.slice(0, 3000)}\n... (truncated)` : c.diff_content,
+	}));
 	const narrativePrompt = exploration
-		? buildEnrichedNarrativePrompt(prData.title, summary, groups, exploration, promptCtx)
-		: buildNarrativePrompt(prData.title, summary, groups, promptCtx);
+		? buildEnrichedNarrativePrompt(prData.title, summary, groups, exploration, promptCtx, fileDiffs)
+		: buildNarrativePrompt(prData.title, summary, groups, promptCtx, fileDiffs);
 	const narrativeResponse = await streamLlmCall(
 		client, narrativePrompt.system, narrativePrompt.user, "narrating", "Writing narrative...", progress,
 	);
@@ -279,7 +299,9 @@ export async function analyzePr(options: PipelineOptions): Promise<NewprOutput>
 		meta: {
 			pr_number: prData.number,
 			pr_title: prData.title,
+			pr_body: prData.body || undefined,
 			pr_url: prData.url,
+			pr_state: prData.state,
 			base_branch: prData.base_branch,
 			head_branch: prData.head_branch,
 			author: prData.author,

package/src/analyzer/progress.ts

@@ -17,6 +17,8 @@ export interface ProgressEvent {
 	total?: number;
 	partial_content?: string;
 	timestamp?: number;
+	pr_title?: string;
+	pr_number?: number;
 }
 
 export type ProgressCallback = (event: ProgressEvent) => void;

package/src/cli/index.ts

@@ -10,8 +10,9 @@ import { analyzePr } from "../analyzer/pipeline.ts";
 import { createStderrProgress, createSilentProgress, createStreamJsonProgress } from "../analyzer/progress.ts";
 import { renderLoading, renderShell } from "../tui/render.tsx";
 import { checkForUpdate, printUpdateNotice } from "./update-check.ts";
+import { runPreflight, printPreflight } from "./preflight.ts";
 
-const VERSION = "0.1.3";
+const VERSION = "0.3.0";
 
 async function main(): Promise<void> {
 	const args = parseArgs(process.argv);
@@ -51,12 +52,14 @@ async function main(): Promise<void> {
 
 	if (args.command === "web") {
 		try {
+			const preflight = await runPreflight();
+			printPreflight(preflight);
 			const config = await loadConfig({ model: args.model });
 			const token = await getGithubToken();
 			const updateInfo = await updatePromise;
 			if (updateInfo) printUpdateNotice(updateInfo);
 			const { startWebServer } = await import("../web/server.ts");
-			await startWebServer({ port: args.port ?? 3000, token, config, cartoon: args.cartoon });
+			await startWebServer({ port: args.port ?? 3000, token, config, cartoon: args.cartoon, preflight });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			process.stderr.write(`Error: ${message}\n`);
@@ -67,6 +70,8 @@ async function main(): Promise<void> {
 
 	if (args.command === "shell") {
 		try {
+			const preflight = await runPreflight();
+			printPreflight(preflight);
 			const config = await loadConfig({ model: args.model });
 			const token = await getGithubToken();
 			const updateInfo = await updatePromise;

package/src/cli/preflight.ts

@@ -0,0 +1,126 @@
+import type { AgentToolName } from "../workspace/types.ts";
+
+export interface ToolStatus {
+	name: string;
+	installed: boolean;
+	version?: string;
+	detail?: string;
+}
+
+export interface PreflightResult {
+	github: ToolStatus & { authenticated: boolean; user?: string };
+	agents: ToolStatus[];
+	openrouterKey: boolean;
+}
+
+async function which(cmd: string): Promise<string | null> {
+	try {
+		const result = await Bun.$`which ${cmd}`.text();
+		return result.trim() || null;
+	} catch {
+		return null;
+	}
+}
+
+async function getVersion(cmd: string, flag = "--version"): Promise<string | null> {
+	try {
+		const result = await Bun.$`${cmd} ${flag} 2>&1`.text();
+		const match = result.match(/[\d]+\.[\d]+[\d.]*/);
+		return match?.[0] ?? result.trim().slice(0, 30);
+	} catch {
+		return null;
+	}
+}
+
+async function checkGithubCli(): Promise<PreflightResult["github"]> {
+	const path = await which("gh");
+	if (!path) {
+		return { name: "gh", installed: false, authenticated: false, detail: "brew install gh" };
+	}
+	const version = await getVersion("gh");
+	try {
+		const status = await Bun.$`gh auth status 2>&1`.text();
+		const userMatch = status.match(/Logged in to github\.com account (\S+)/i)
+			?? status.match(/account (\S+)/i);
+		return {
+			name: "gh",
+			installed: true,
+			version: version ?? undefined,
+			authenticated: true,
+			user: userMatch?.[1]?.replace(/\s*\(.*/, ""),
+		};
+	} catch {
+		return { name: "gh", installed: true, version: version ?? undefined, authenticated: false, detail: "gh auth login" };
+	}
+}
+
+async function checkAgent(name: AgentToolName): Promise<ToolStatus> {
+	const path = await which(name);
+	if (!path) return { name, installed: false };
+	const version = await getVersion(name);
+	return { name, installed: true, version: version ?? undefined };
+}
+
+export async function runPreflight(): Promise<PreflightResult> {
+	const [github, claude, opencode, codex] = await Promise.all([
+		checkGithubCli(),
+		checkAgent("claude"),
+		checkAgent("opencode"),
+		checkAgent("codex"),
+	]);
+
+	return {
+		github,
+		agents: [claude, opencode, codex],
+		openrouterKey: !!(process.env.OPENROUTER_API_KEY || await hasStoredApiKey()),
+	};
+}
+
+async function hasStoredApiKey(): Promise<boolean> {
+	try {
+		const { readStoredConfig } = await import("../config/store.ts");
+		const stored = await readStoredConfig();
+		return !!stored.openrouter_api_key;
+	} catch {
+		return false;
+	}
+}
+
+export function printPreflight(result: PreflightResult): void {
+	const check = "\x1b[32m✓\x1b[0m";
+	const cross = "\x1b[31m✗\x1b[0m";
+	const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
+	const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
+
+	console.log("");
+	console.log(`  ${bold("Preflight")}`);
+	console.log("");
+
+	const gh = result.github;
+	if (gh.installed && gh.authenticated) {
+		console.log(`  ${check} gh ${dim(gh.version ?? "")} ${dim(`· ${gh.user ?? ""}`)}`);
+	} else if (gh.installed) {
+		console.log(`  ${cross} gh ${dim(gh.version ?? "")} ${dim("· not authenticated")}`);
+		console.log(`    ${dim(`run: ${gh.detail}`)}`);
+	} else {
+		console.log(`  ${cross} gh ${dim("· not installed")}`);
+		console.log(`    ${dim(`run: ${gh.detail}`)}`);
+	}
+
+	for (const agent of result.agents) {
+		if (agent.installed) {
+			console.log(`  ${check} ${agent.name} ${dim(agent.version ?? "")}`);
+		} else {
+			console.log(`  ${dim("·")} ${dim(agent.name)} ${dim("not found")}`);
+		}
+	}
+
+	if (result.openrouterKey) {
+		console.log(`  ${check} OpenRouter API key`);
+	} else {
+		console.log(`  ${cross} OpenRouter API key ${dim("· not configured")}`);
+		console.log(`    ${dim("run: newpr auth")}`);
+	}
+
+	console.log("");
+}

package/src/github/fetch-pr.ts

@@ -1,14 +1,25 @@
-import type { GithubPrData, PrCommit, PrIdentifier } from "../types/github.ts";
+import type { GithubPrData, PrComment, PrCommit, PrIdentifier, PrState } from "../types/github.ts";
 
 export function mapPrResponse(json: Record<string, unknown>): Omit<GithubPrData, "commits"> {
 	const user = json.user as Record<string, unknown> | undefined;
 	const base = json.base as Record<string, unknown> | undefined;
 	const head = json.head as Record<string, unknown> | undefined;
 
+	let state: PrState = "open";
+	if (json.draft) {
+		state = "draft";
+	} else if (json.merged) {
+		state = "merged";
+	} else if (json.state === "closed") {
+		state = "closed";
+	}
+
 	return {
 		number: json.number as number,
 		title: json.title as string,
+		body: (json.body as string) ?? "",
 		url: json.html_url as string,
+		state,
 		base_branch: (base?.ref as string) ?? "unknown",
 		head_branch: (head?.ref as string) ?? "unknown",
 		author: (user?.login as string) ?? "unknown",
@@ -88,3 +99,44 @@ export async function fetchPrData(pr: PrIdentifier, token: string): Promise<Gith
 
 	return { ...base, commits };
 }
+
+interface GithubCommentResponse {
+	id: number;
+	user: { login: string; avatar_url?: string } | null;
+	body: string;
+	created_at: string;
+	updated_at: string;
+	html_url: string;
+}
+
+export async function fetchPrComments(pr: PrIdentifier, token: string): Promise<PrComment[]> {
+	const allComments: GithubCommentResponse[] = [];
+	let page = 1;
+
+	while (true) {
+		const url = `https://api.github.com/repos/${pr.owner}/${pr.repo}/issues/${pr.number}/comments?per_page=100&page=${page}`;
+		const response = await githubGet(url, token);
+		const items = (await response.json()) as GithubCommentResponse[];
+		if (items.length === 0) break;
+		allComments.push(...items);
+		if (items.length < 100) break;
+		page++;
+	}
+
+	return allComments.map((c) => ({
+		id: c.id,
+		author: c.user?.login ?? "unknown",
+		author_avatar: c.user?.avatar_url ?? undefined,
+		body: c.body,
+		created_at: c.created_at,
+		updated_at: c.updated_at,
+		html_url: c.html_url,
+	}));
+}
+
+export async function fetchPrBody(pr: PrIdentifier, token: string): Promise<string> {
+	const url = `https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}`;
+	const response = await githubGet(url, token);
+	const json = (await response.json()) as Record<string, unknown>;
+	return (json.body as string) ?? "";
+}

package/src/history/store.ts

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { mkdirSync, rmSync, existsSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import type { NewprOutput } from "../types/output.ts";
+import type { NewprOutput, DiffComment, ChatMessage, CartoonImage } from "../types/output.ts";
 import type { SessionRecord } from "./types.ts";
 
 const HISTORY_DIR = join(homedir(), ".newpr", "history");
@@ -25,6 +25,7 @@ export function buildSessionRecord(id: string, data: NewprOutput): SessionRecord
 		pr_url: meta.pr_url,
 		pr_number: meta.pr_number,
 		pr_title: meta.pr_title,
+		pr_state: meta.pr_state,
 		repo: repoParts?.[1] ?? "unknown",
 		author: meta.author,
 		analyzed_at: meta.analyzed_at,
@@ -91,6 +92,111 @@ export async function clearHistory(): Promise<void> {
 	}
 }
 
+export async function savePatchesSidecar(
+	id: string,
+	patches: Record<string, string>,
+): Promise<void> {
+	ensureDirs();
+	await Bun.write(
+		join(SESSIONS_DIR, `${id}.patches.json`),
+		JSON.stringify(patches),
+	);
+}
+
+export async function loadPatchesSidecar(
+	id: string,
+): Promise<Record<string, string> | null> {
+	try {
+		const filePath = join(SESSIONS_DIR, `${id}.patches.json`);
+		const file = Bun.file(filePath);
+		if (!(await file.exists())) return null;
+		return JSON.parse(await file.text()) as Record<string, string>;
+	} catch {
+		return null;
+	}
+}
+
+export async function loadSinglePatch(
+	id: string,
+	filePath: string,
+): Promise<string | null> {
+	const patches = await loadPatchesSidecar(id);
+	if (!patches) return null;
+	return patches[filePath] ?? null;
+}
+
+export async function saveCommentsSidecar(
+	id: string,
+	comments: DiffComment[],
+): Promise<void> {
+	ensureDirs();
+	await Bun.write(
+		join(SESSIONS_DIR, `${id}.comments.json`),
+		JSON.stringify(comments, null, 2),
+	);
+}
+
+export async function loadCommentsSidecar(
+	id: string,
+): Promise<DiffComment[] | null> {
+	try {
+		const filePath = join(SESSIONS_DIR, `${id}.comments.json`);
+		const file = Bun.file(filePath);
+		if (!(await file.exists())) return null;
+		return JSON.parse(await file.text()) as DiffComment[];
+	} catch {
+		return null;
+	}
+}
+
+export async function saveChatSidecar(
+	id: string,
+	messages: ChatMessage[],
+): Promise<void> {
+	ensureDirs();
+	await Bun.write(
+		join(SESSIONS_DIR, `${id}.chat.json`),
+		JSON.stringify(messages, null, 2),
+	);
+}
+
+export async function loadChatSidecar(
+	id: string,
+): Promise<ChatMessage[] | null> {
+	try {
+		const filePath = join(SESSIONS_DIR, `${id}.chat.json`);
+		const file = Bun.file(filePath);
+		if (!(await file.exists())) return null;
+		return JSON.parse(await file.text()) as ChatMessage[];
+	} catch {
+		return null;
+	}
+}
+
+export async function saveCartoonSidecar(
+	id: string,
+	cartoon: CartoonImage,
+): Promise<void> {
+	ensureDirs();
+	await Bun.write(
+		join(SESSIONS_DIR, `${id}.cartoon.json`),
+		JSON.stringify(cartoon),
+	);
+}
+
+export async function loadCartoonSidecar(
+	id: string,
+): Promise<CartoonImage | null> {
+	try {
+		const filePath = join(SESSIONS_DIR, `${id}.cartoon.json`);
+		const file = Bun.file(filePath);
+		if (!(await file.exists())) return null;
+		return JSON.parse(await file.text()) as CartoonImage;
+	} catch {
+		return null;
+	}
+}
+
 export function getHistoryPath(): string {
 	return HISTORY_DIR;
 }

package/src/history/types.ts

@@ -3,6 +3,7 @@ export interface SessionRecord {
 	pr_url: string;
 	pr_number: number;
 	pr_title: string;
+	pr_state?: string;
 	repo: string;
 	author: string;
 	analyzed_at: string;