newpr 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "0.1.3",
+  "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/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/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" });
+}

package/src/llm/prompts.ts

@@ -17,6 +17,8 @@ export interface FileSummaryInput {
 export interface PromptContext {
 	commits?: PrCommit[];
 	language?: string;
+	prBody?: string;
+	discussion?: Array<{ author: string; body: string }>;
 }
 
 function langDirective(lang?: string): string {
@@ -24,6 +26,21 @@ function langDirective(lang?: string): string {
 	return `\nCRITICAL LANGUAGE RULE: ALL text values in your response MUST be written in ${lang}. This includes every summary, description, name, purpose, scope, and impact field. JSON keys stay in English, but ALL string values MUST be in ${lang}. Do NOT use English for any descriptive text.`;
 }
 
+function formatDiscussion(ctx?: PromptContext): string {
+	const parts: string[] = [];
+	if (ctx?.prBody?.trim()) {
+		parts.push(`PR Description:\n${ctx.prBody.trim()}`);
+	}
+	if (ctx?.discussion && ctx.discussion.length > 0) {
+		const comments = ctx.discussion
+			.map((c) => `@${c.author}: ${c.body.length > 500 ? `${c.body.slice(0, 500)}…` : c.body}`)
+			.join("\n\n");
+		parts.push(`Discussion (${ctx.discussion.length} comments):\n${comments}`);
+	}
+	if (parts.length === 0) return "";
+	return `\n\n--- PR DISCUSSION ---\n${parts.join("\n\n")}`;
+}
+
 function formatCommitHistory(commits: PrCommit[]): string {
 	if (commits.length === 0) return "";
 	const lines = commits.map((c) => {
@@ -44,13 +61,15 @@ export function buildFileSummaryPrompt(chunks: DiffChunk[], ctx?: PromptContext)
 
 	const commitCtx = ctx?.commits ? formatCommitHistory(ctx.commits) : "";
 
+	const discussionCtx = formatDiscussion(ctx);
+
 	return {
 		system: `You are an expert code reviewer. Analyze the given diff and provide a 1-line summary for each changed file.
-Use the commit history to understand the intent behind each change — why the change was made, not just what changed.
+Use the commit history and PR discussion to understand the intent behind each change — why the change was made, not just what changed.
 Respond ONLY with a JSON array. Each element: {"path": "file/path", "summary": "one line description of what changed"}.
 The "path" value must be the exact file path. The "summary" value is a human-readable description.
 No markdown, no explanation, just the JSON array.${langDirective(ctx?.language)}`,
-		user: `${fileList}${commitCtx}`,
+		user: `${fileList}${commitCtx}${discussionCtx}`,
 	};
 }
 
@@ -61,15 +80,17 @@ export function buildGroupingPrompt(fileSummaries: FileSummaryInput[], ctx?: Pro
 
 	const commitCtx = ctx?.commits ? formatCommitHistory(ctx.commits) : "";
 
+	const discussionCtx = formatDiscussion(ctx);
+
 	return {
 		system: `You are an expert code reviewer. Group the following changed files by their semantic purpose.
 Each group should have a descriptive name, a type (one of: feature, refactor, bugfix, chore, docs, test, config), a description, and a list of file paths.
 A file MAY appear in multiple groups if it serves multiple purposes (e.g., index.ts re-exporting for both a feature and a refactor).
-Use the commit history to understand which changes belong together logically.
+Use the commit history and PR discussion to understand which changes belong together logically.
 Respond ONLY with a JSON array. Each element: {"name": "group name", "type": "feature|refactor|bugfix|chore|docs|test|config", "description": "what this group of changes does", "files": ["path1", "path2"]}.
 The "name" and "description" values are human-readable text. The "type" value must be one of the English keywords listed above. File paths stay as-is.
 Every file must appear in at least one group. No markdown, no explanation, just the JSON array.${langDirective(ctx?.language)}`,
-		user: `Changed files:\n${fileList}${commitCtx}`,
+		user: `Changed files:\n${fileList}${commitCtx}${discussionCtx}`,
 	};
 }
 
@@ -86,13 +107,15 @@ export function buildOverallSummaryPrompt(
 	const fileList = fileSummaries.map((f) => `- ${f.path}: ${f.summary}`).join("\n");
 	const commitCtx = ctx?.commits ? formatCommitHistory(ctx.commits) : "";
 
+	const discussionCtx = formatDiscussion(ctx);
+
 	return {
 		system: `You are an expert code reviewer. Provide an overall summary of this Pull Request.
-Use the commit history to understand the development progression and intent.
+Use the commit history and PR discussion to understand the development progression and intent. The PR description and reviewer comments provide essential context about why changes were made.
 Respond ONLY with a JSON object: {"purpose": "why this PR exists (1-2 sentences)", "scope": "what areas of code are affected", "impact": "what is the impact of these changes", "risk_level": "low|medium|high"}.
 The "purpose", "scope", and "impact" values are human-readable text. The "risk_level" must be one of: low, medium, high (in English).
 No markdown, no explanation, just the JSON object.${langDirective(ctx?.language)}`,
-		user: `PR Title: ${prTitle}\n\nChange Groups:\n${groupList}\n\nFile Summaries:\n${fileList}${commitCtx}`,
+		user: `PR Title: ${prTitle}\n\nChange Groups:\n${groupList}\n\nFile Summaries:\n${fileList}${commitCtx}${discussionCtx}`,
 	};
 }
 
@@ -109,17 +132,19 @@ export function buildNarrativePrompt(
 	const commitCtx = ctx?.commits ? formatCommitHistory(ctx.commits) : "";
 	const lang = ctx?.language && ctx.language !== "English" ? ctx.language : null;
 
+	const discussionCtx = formatDiscussion(ctx);
+
 	return {
 		system: `You are an expert code reviewer writing a review walkthrough for other developers.
 Write a clear, concise narrative that tells the "story" of this PR — what changes were made and in what logical order.
-Use the commit history to understand the development progression: which changes came first, how the PR evolved, and the intent behind each step.
+Use the commit history and PR discussion to understand the development progression: which changes came first, how the PR evolved, and the intent behind each step. The PR description often explains the author's motivation and approach.
 Use markdown formatting. Write 2-5 paragraphs. Do NOT use JSON. Write natural prose.
 ${lang ? `CRITICAL: Write the ENTIRE narrative in ${lang}. Every sentence must be in ${lang}. Do NOT use English except for code identifiers, file paths, and [[group:...]]/[[file:...]] tokens.` : "If the PR title is in a non-English language, write the narrative in that same language."}
 
 IMPORTANT: When referencing a change group, wrap it as [[group:Group Name]]. When referencing a specific file, wrap it as [[file:path/to/file.ts]].
 Use the EXACT group names and file paths provided. Every group MUST be referenced at least once. Reference key files where relevant.
 Example: "The [[group:Auth Flow]] group introduces session management via [[file:src/auth/session.ts]] and [[file:src/auth/token.ts]]."`,
-		user: `PR Title: ${prTitle}\n\nSummary:\n- Purpose: ${summary.purpose}\n- Scope: ${summary.scope}\n- Impact: ${summary.impact}\n- Risk: ${summary.risk_level}\n\nChange Groups:\n${groupDetails}${commitCtx}`,
+		user: `PR Title: ${prTitle}\n\nSummary:\n- Purpose: ${summary.purpose}\n- Scope: ${summary.scope}\n- Impact: ${summary.impact}\n- Risk: ${summary.risk_level}\n\nChange Groups:\n${groupDetails}${commitCtx}${discussionCtx}`,
 	};
 }
 

package/src/tui/Shell.tsx

@@ -7,7 +7,7 @@ import type { SessionRecord } from "../history/types.ts";
 import type { AgentToolName } from "../workspace/types.ts";
 import { parsePrInput } from "../github/parse-pr.ts";
 import { analyzePr } from "../analyzer/pipeline.ts";
-import { saveSession, listSessions, loadSession } from "../history/store.ts";
+import { saveSession, savePatchesSidecar, listSessions, loadSession } from "../history/store.ts";
 import { detectAgents } from "../workspace/agent.ts";
 import { App } from "./App.tsx";
 import { InputBar } from "./InputBar.tsx";
@@ -94,10 +94,12 @@ export function Shell({ token, config: initialConfig, initialPr }: ShellProps) {
 				setState({ phase: "loading", steps: [], startTime });
 				setElapsed(0);
 
+				let capturedPatches: Record<string, string> = {};
 				const result = await analyzePr({
 					pr,
 					token,
 					config: liveConfig,
+					onFilePatches: (patches) => { capturedPatches = patches; },
 					onProgress: (event: ProgressEvent) => {
 						const stamped = { ...event, timestamp: event.timestamp ?? Date.now() };
 						const prev = eventsRef.current;
@@ -117,7 +119,10 @@ export function Shell({ token, config: initialConfig, initialPr }: ShellProps) {
 					},
 				});
 
-				await saveSession(result);
+				const record = await saveSession(result);
+				if (Object.keys(capturedPatches).length > 0) {
+					await savePatchesSidecar(record.id, capturedPatches).catch(() => {});
+				}
 				const updated = await listSessions(10);
 				setSessions(updated);
 

package/src/types/github.ts

@@ -12,9 +12,20 @@ export interface PrCommit {
 	files: string[];
 }
 
+export interface PrComment {
+	id: number;
+	author: string;
+	author_avatar?: string;
+	body: string;
+	created_at: string;
+	updated_at: string;
+	html_url: string;
+}
+
 export interface GithubPrData {
 	number: number;
 	title: string;
+	body: string;
 	url: string;
 	base_branch: string;
 	head_branch: string;