newpr 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "0.1.1",
+  "version": "0.2.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;
 }
@@ -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` });
 
 	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({
@@ -279,6 +295,7 @@ 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,
 			base_branch: prData.base_branch,
 			head_branch: prData.head_branch,

package/src/cli/args.ts

@@ -10,6 +10,7 @@ export interface CliArgs {
 	noClone: boolean;
 	agent?: AgentToolName;
 	port?: number;
+	cartoon?: boolean;
 	subArgs: string[];
 }
 
@@ -101,8 +102,12 @@ export function parseArgs(argv: string[]): CliArgs {
 		const portIdx = args.indexOf("--port");
 		if (portIdx !== -1 && args[portIdx + 1]) {
 			port = Number.parseInt(args[portIdx + 1]!, 10) || 3000;
+		} else {
+			const eqArg = args.find((a) => a.startsWith("--port="));
+			if (eqArg) port = Number.parseInt(eqArg.split("=")[1]!, 10) || 3000;
 		}
-		return { command: "web", port, ...DEFAULTS };
+		const cartoon = args.includes("--cartoon");
+		return { command: "web", port, cartoon, ...DEFAULTS };
 	}
 
 	if (args.length === 0) {

package/src/cli/index.ts

@@ -11,7 +11,7 @@ import { createStderrProgress, createSilentProgress, createStreamJsonProgress }
 import { renderLoading, renderShell } from "../tui/render.tsx";
 import { checkForUpdate, printUpdateNotice } from "./update-check.ts";
 
-const VERSION = "0.1.1";
+const VERSION = "0.1.3";
 
 async function main(): Promise<void> {
 	const args = parseArgs(process.argv);
@@ -56,7 +56,7 @@ async function main(): Promise<void> {
 			const updateInfo = await updatePromise;
 			if (updateInfo) printUpdateNotice(updateInfo);
 			const { startWebServer } = await import("../web/server.ts");
-			await startWebServer({ port: args.port ?? 3000, token, config });
+			await startWebServer({ port: args.port ?? 3000, token, config, cartoon: args.cartoon });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			process.stderr.write(`Error: ${message}\n`);

package/src/github/fetch-pr.ts

@@ -1,4 +1,4 @@
-import type { GithubPrData, PrCommit, PrIdentifier } from "../types/github.ts";
+import type { GithubPrData, PrComment, PrCommit, PrIdentifier } from "../types/github.ts";
 
 export function mapPrResponse(json: Record<string, unknown>): Omit<GithubPrData, "commits"> {
 	const user = json.user as Record<string, unknown> | undefined;
@@ -8,6 +8,7 @@ export function mapPrResponse(json: Record<string, unknown>): Omit<GithubPrData,
 	return {
 		number: json.number as number,
 		title: json.title as string,
+		body: (json.body as string) ?? "",
 		url: json.html_url as string,
 		base_branch: (base?.ref as string) ?? "unknown",
 		head_branch: (head?.ref as string) ?? "unknown",
@@ -88,3 +89,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");
@@ -91,6 +91,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/llm/cartoon.ts

@@ -0,0 +1,128 @@
+import type { NewprOutput } from "../types/output.ts";
+
+const CARTOON_MODEL = "google/gemini-3-pro-image-preview";
+
+function buildCartoonPrompt(data: NewprOutput, language: string): string {
+	const { meta, summary, groups, narrative } = data;
+	const lang = language === "auto" ? "English" : language;
+	const groupList = groups.slice(0, 5).map((g) => `- ${g.name}: ${g.description.slice(0, 80)}`).join("\n");
+	const storyExcerpt = narrative
+		.replace(/\[\[(group|file):[^\]]+\]\]/g, "")
+		.split("\n")
+		.filter((l) => l.trim() && !l.startsWith("#"))
+		.slice(0, 6)
+		.join(" ")
+		.slice(0, 500);
+
+	return `Generate an image of a funny 4-panel comic strip about this Pull Request.
+
+## PR Context
+Title: "${meta.pr_title}"
+Author: ${meta.author}
+Purpose: ${summary.purpose}
+Scope: ${summary.scope}
+Impact: ${summary.impact}
+Risk: ${summary.risk_level}
+Changes: +${meta.total_additions} -${meta.total_deletions} across ${meta.total_files_changed} files
+
+## What happened (key changes):
+${groupList}
+
+## Story:
+${storyExcerpt}
+
+## Comic Requirements:
+- 2x2 grid, 4 panels
+- Cute stick-figure developer characters with expressive faces and gestures
+- Speech bubbles with SHORT, witty dialogue in ${lang}
+- Panel 1: The developer discovers the problem or receives the task (based on the PR purpose above)
+- Panel 2: The developer's ambitious plan or approach (based on the actual changes)
+- Panel 3: A funny complication that reflects the real complexity (based on risk/impact)
+- Panel 4: The resolution with a developer humor punchline
+- The humor should be SPECIFIC to this PR's content, not generic programming jokes
+- Make the characters expressive and the scenes detailed
+- The image must be square (1:1 aspect ratio, 1080x1080px), suitable for Instagram
+- Output only the image`;
+}
+
+interface CartoonResponse {
+	choices: Array<{
+		message: {
+			content: string;
+			images?: Array<{
+				image_url: { url: string };
+			}>;
+		};
+	}>;
+}
+
+const MAX_RETRIES = 3;
+
+export async function generateCartoon(
+	apiKey: string,
+	data: NewprOutput,
+	language: string,
+): Promise<{ imageBase64: string; mimeType: string }> {
+	const prompt = buildCartoonPrompt(data, language);
+
+	for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+		const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				"Content-Type": "application/json",
+				"HTTP-Referer": "https://github.com/jiwonMe/newpr",
+				"X-Title": "newpr-cartoon",
+			},
+			body: JSON.stringify({
+				model: CARTOON_MODEL,
+				messages: [
+					{ role: "user", content: prompt },
+				],
+				modalities: ["image", "text"],
+				temperature: 1.0,
+			}),
+		});
+
+		if (response.status === 500 || response.status === 502 || response.status === 503) {
+			if (attempt < MAX_RETRIES) {
+				await new Promise((r) => setTimeout(r, 2000 * attempt));
+				continue;
+			}
+		}
+
+		if (!response.ok) {
+			const body = await response.text();
+			throw new Error(`Cartoon generation failed (${response.status}): ${body.slice(0, 300)}`);
+		}
+
+		const result = await response.json() as CartoonResponse;
+		const message = result.choices?.[0]?.message;
+
+		if (message?.images?.length) {
+			const imageUrl = message.images[0]!.image_url.url;
+			const match = imageUrl.match(/^data:image\/(png|jpeg|webp|gif);base64,(.+)$/);
+			if (match) {
+				return { imageBase64: match[2]!, mimeType: `image/${match[1]}` };
+			}
+			const imgRes = await fetch(imageUrl);
+			if (imgRes.ok) {
+				const buf = await imgRes.arrayBuffer();
+				return {
+					imageBase64: Buffer.from(buf).toString("base64"),
+					mimeType: imgRes.headers.get("content-type") ?? "image/png",
+				};
+			}
+		}
+
+		if (attempt < MAX_RETRIES) {
+			await new Promise((r) => setTimeout(r, 2000 * attempt));
+			continue;
+		}
+
+		const raw = JSON.stringify(result).slice(0, 500);
+		throw new Error(`No image in response. Raw: ${raw}`);
+	}
+
+	throw new Error("Cartoon generation failed after retries");
+}

package/src/llm/client.ts

@@ -238,3 +238,200 @@ export function createLlmClient(options: LlmClientOptions): LlmClient {
 	const { createClaudeCodeClient: create } = require("./claude-code-client.ts");
 	return create(options.timeout);
 }
+
+export interface ChatTool {
+	type: "function";
+	function: {
+		name: string;
+		description: string;
+		parameters: Record<string, unknown>;
+	};
+}
+
+export interface ChatToolCallDelta {
+	id: string;
+	name: string;
+	arguments: string;
+}
+
+export interface ChatStreamEvent {
+	type: "text" | "tool_call" | "tool_result" | "done" | "error";
+	content?: string;
+	toolCall?: ChatToolCallDelta;
+	toolResult?: { id: string; result: string };
+	error?: string;
+}
+
+export type ChatStreamCallback = (event: ChatStreamEvent) => void;
+
+interface OpenRouterChatMessage {
+	role: "system" | "user" | "assistant" | "tool";
+	content?: string | null;
+	tool_calls?: Array<{
+		id: string;
+		type: "function";
+		function: { name: string; arguments: string };
+	}>;
+	tool_call_id?: string;
+}
+
+interface OpenRouterStreamToolCallDelta {
+	index?: number;
+	id?: string;
+	type?: string;
+	function?: { name?: string; arguments?: string };
+}
+
+interface OpenRouterStreamChunkWithTools {
+	choices: Array<{
+		delta: {
+			content?: string;
+			tool_calls?: OpenRouterStreamToolCallDelta[];
+		};
+		finish_reason?: string | null;
+	}>;
+	model?: string;
+	usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number };
+}
+
+export async function chatWithTools(
+	options: LlmClientOptions,
+	messages: OpenRouterChatMessage[],
+	tools: ChatTool[],
+	executeTool: (name: string, args: Record<string, unknown>) => Promise<string>,
+	onEvent: ChatStreamCallback,
+): Promise<void> {
+	const MAX_TOOL_ROUNDS = 10;
+
+	let currentMessages = [...messages];
+
+	for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), options.timeout * 1000);
+
+		let response: Response;
+		try {
+			response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+				method: "POST",
+				signal: controller.signal,
+				headers: {
+					Authorization: `Bearer ${options.api_key}`,
+					"Content-Type": "application/json",
+					"HTTP-Referer": "https://github.com/sionic/newpr",
+					"X-Title": "newpr",
+				},
+				body: JSON.stringify({
+					model: options.model,
+					messages: currentMessages,
+					tools: tools.length > 0 ? tools : undefined,
+					temperature: 0.3,
+					stream: true,
+				}),
+			});
+		} catch (err) {
+			clearTimeout(timeoutId);
+			onEvent({ type: "error", error: err instanceof Error ? err.message : String(err) });
+			return;
+		}
+
+		clearTimeout(timeoutId);
+
+		if (!response.ok) {
+			const body = await response.text();
+			onEvent({ type: "error", error: `OpenRouter API error ${response.status}: ${body}` });
+			return;
+		}
+
+		const reader = response.body!.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let textContent = "";
+		const toolCalls = new Map<number, { id: string; name: string; arguments: string }>();
+
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() ?? "";
+
+				for (const line of lines) {
+					const trimmed = line.trim();
+					if (!trimmed || trimmed === "data: [DONE]") continue;
+					if (!trimmed.startsWith("data: ")) continue;
+
+					try {
+						const chunk = JSON.parse(trimmed.slice(6)) as OpenRouterStreamChunkWithTools;
+						const delta = chunk.choices[0]?.delta;
+						if (!delta) continue;
+
+						if (delta.content) {
+							textContent += delta.content;
+							onEvent({ type: "text", content: delta.content });
+						}
+
+						if (delta.tool_calls) {
+							for (const tc of delta.tool_calls) {
+								const idx = tc.index ?? 0;
+								if (!toolCalls.has(idx)) {
+									toolCalls.set(idx, { id: tc.id ?? "", name: "", arguments: "" });
+								}
+								const entry = toolCalls.get(idx)!;
+								if (tc.id) entry.id = tc.id;
+								if (tc.function?.name) entry.name += tc.function.name;
+								if (tc.function?.arguments) entry.arguments += tc.function.arguments;
+							}
+						}
+					} catch {}
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+
+		if (toolCalls.size === 0) {
+			onEvent({ type: "done" });
+			return;
+		}
+
+		const assistantMsg: OpenRouterChatMessage = {
+			role: "assistant",
+			content: textContent || null,
+			tool_calls: [...toolCalls.values()].map((tc) => ({
+				id: tc.id,
+				type: "function" as const,
+				function: { name: tc.name, arguments: tc.arguments },
+			})),
+		};
+		currentMessages.push(assistantMsg);
+
+		for (const tc of toolCalls.values()) {
+			onEvent({
+				type: "tool_call",
+				toolCall: { id: tc.id, name: tc.name, arguments: tc.arguments },
+			});
+
+			let args: Record<string, unknown> = {};
+			try { args = JSON.parse(tc.arguments); } catch {}
+
+			let result: string;
+			try {
+				result = await executeTool(tc.name, args);
+			} catch (err) {
+				result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+			}
+
+			onEvent({ type: "tool_result", toolResult: { id: tc.id, result } });
+
+			currentMessages.push({
+				role: "tool",
+				content: result,
+				tool_call_id: tc.id,
+			});
+		}
+	}
+
+	onEvent({ type: "done" });
+}