newpr 0.3.0 → 0.5.0

package/src/web/server/routes.ts

@@ -1,15 +1,16 @@
 import type { NewprConfig } from "../../types/config.ts";
 import type { NewprOutput, ChatMessage, ChatToolCall, ChatSegment } from "../../types/output.ts";
 import { DEFAULT_CONFIG } from "../../types/config.ts";
-import { listSessions, loadSession, loadSinglePatch, savePatchesSidecar, loadCommentsSidecar, saveCommentsSidecar, loadChatSidecar, saveChatSidecar, loadPatchesSidecar, saveCartoonSidecar, loadCartoonSidecar } from "../../history/store.ts";
+import { listSessions, loadSession, loadSinglePatch, savePatchesSidecar, loadCommentsSidecar, saveCommentsSidecar, loadChatSidecar, saveChatSidecar, loadPatchesSidecar, saveCartoonSidecar, loadCartoonSidecar, saveSlidesSidecar, loadSlidesSidecar } from "../../history/store.ts";
 import type { DiffComment } from "../../types/output.ts";
 import { fetchPrDiff } from "../../github/fetch-diff.ts";
 import { fetchPrBody, fetchPrComments } from "../../github/fetch-pr.ts";
 import { parseDiff } from "../../diff/parser.ts";
 import { parsePrInput } from "../../github/parse-pr.ts";
 import { writeStoredConfig, type StoredConfig } from "../../config/store.ts";
-import { startAnalysis, getSession, cancelAnalysis, subscribe } from "./session-manager.ts";
+import { startAnalysis, getSession, cancelAnalysis, subscribe, listActiveSessions } from "./session-manager.ts";
 import { generateCartoon } from "../../llm/cartoon.ts";
+import { generateSlides } from "../../llm/slides.ts";
 import { chatWithTools, type ChatTool, type ChatStreamEvent } from "../../llm/client.ts";
 import { detectAgents, runAgent } from "../../workspace/agent.ts";
 import { randomBytes } from "node:crypto";
@@ -70,6 +71,16 @@ export function createRoutes(token: string, config: NewprConfig, options: RouteO
 		return { login: "anonymous" };
 	}
 
+	interface SlideJob {
+		status: "running" | "done" | "error";
+		message: string;
+		current: number;
+		total: number;
+		plan?: { stylePrompt: string; slides: Array<{ index: number; title: string; contentPrompt: string }> };
+		imagePrompts?: Array<{ index: number; prompt: string }>;
+	}
+	const slideJobs = new Map<string, SlideJob>();
+
 	function buildChatSystemPrompt(data: NewprOutput): string {
 		const fileSummaries = data.files
 			.map((f) => `- ${f.path} (${f.status}, +${f.additions}/-${f.deletions}): ${f.summary}`)
@@ -182,6 +193,14 @@ $$
 					parameters: { type: "object", properties: {} },
 				},
 			},
+			{
+				type: "function",
+				function: {
+					name: "run_react_doctor",
+					description: "Run react-doctor on the PR's codebase to get a React code quality score (0-100) and diagnostics for security, performance, correctness, and architecture issues. Only useful for React/JSX/TSX projects.",
+					parameters: { type: "object", properties: {} },
+				},
+			},
 			{
 				type: "function",
 				function: {
@@ -215,7 +234,7 @@ $$
 
 	return {
 		"POST /api/analysis": async (req: Request) => {
-			const body = await req.json() as { pr: string };
+			const body = await req.json() as { pr: string; reuseSessionId?: string };
 			if (!body.pr) return json({ error: "Missing 'pr' field" }, 400);
 
 			const result = startAnalysis(body.pr, token, config);
@@ -223,6 +242,7 @@ $$
 
 			return json({
 				sessionId: result.sessionId,
+				reuseSessionId: body.reuseSessionId,
 				eventsUrl: `/api/analysis/${result.sessionId}/events`,
 			});
 		},
@@ -526,7 +546,8 @@ $$
 		},
 
 		"GET /api/features": () => {
-			return json({ cartoon: !!options.cartoon });
+			const { getVersion } = require("../../version.ts");
+			return json({ cartoon: !!options.cartoon, version: getVersion() });
 		},
 
 		"POST /api/review": async (req: Request) => {
@@ -564,6 +585,10 @@ $$
 			return json(options.preflight ?? null);
 		},
 
+		"GET /api/active-analyses": () => {
+			return json(listActiveSessions());
+		},
+
 		"GET /api/sessions/:id/comments": async (req: Request) => {
 			const url = new URL(req.url);
 			const segments = url.pathname.split("/");
@@ -713,6 +738,107 @@ $$
 			return json({ ok: true });
 		},
 
+		"POST /api/sessions/:id/ask-inline": async (req: Request) => {
+			const url = new URL(req.url);
+			const segments = url.pathname.split("/");
+			const sessionId = segments[3]!;
+
+			if (!config.openrouter_api_key) {
+				return json({ error: "OpenRouter API key required" }, 400);
+			}
+
+			const body = await req.json() as { message: string };
+			if (!body.message?.trim()) return json({ error: "Missing message" }, 400);
+
+			const sessionData = await loadSession(sessionId);
+			if (!sessionData) return json({ error: "Session not found" }, 404);
+
+			const systemPrompt = buildChatSystemPrompt(sessionData);
+			const apiMessages = [
+				{ role: "system" as const, content: systemPrompt },
+				{ role: "user" as const, content: body.message.trim() },
+			];
+
+			const encoder = new TextEncoder();
+			const stream = new ReadableStream({
+				async start(controller) {
+					const send = (eventType: string, data: string) => {
+						controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${data}\n\n`));
+					};
+					try {
+						await chatWithTools(
+							{ api_key: config.openrouter_api_key, model: config.model, timeout: config.timeout },
+							apiMessages as Parameters<typeof chatWithTools>[1],
+							buildChatTools(),
+							async (name: string, args: Record<string, unknown>): Promise<string> => {
+								if (name === "get_file_diff") {
+									const filePath = args.path as string;
+									if (!filePath) return "Error: path required";
+									const patches = await loadPatchesSidecar(sessionId);
+									if (patches?.[filePath]) return patches[filePath];
+									const patch = await loadSinglePatch(sessionId, filePath);
+									if (patch) return patch;
+									return `File "${filePath}" not found`;
+								}
+								if (name === "list_files") {
+									return sessionData.files.map((f) => `${f.path} (${f.status}): ${f.summary}`).join("\n");
+								}
+								return `Tool ${name} not available in inline mode`;
+							},
+							(event: ChatStreamEvent) => {
+								if (event.type === "text") send("text", JSON.stringify({ content: event.content }));
+								else if (event.type === "error") send("chat_error", JSON.stringify({ message: event.error }));
+								else if (event.type === "done") send("done", JSON.stringify({}));
+							},
+						);
+						send("done", JSON.stringify({}));
+					} catch (err) {
+						send("chat_error", JSON.stringify({ message: err instanceof Error ? err.message : String(err) }));
+					} finally {
+						controller.close();
+					}
+				},
+			});
+
+			return new Response(stream, {
+				headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" },
+			});
+		},
+
+		"GET /api/sessions/:id/outdated": async (req: Request) => {
+			const url = new URL(req.url);
+			const segments = url.pathname.split("/");
+			const id = segments[3]!;
+			const sessionData = await loadSession(id);
+			if (!sessionData) return json({ error: "Session not found" }, 404);
+
+			const prUrl = sessionData.meta.pr_url;
+			const analyzedUpdatedAt = sessionData.meta.pr_updated_at;
+			if (!analyzedUpdatedAt) return json({ outdated: false, reason: "no_baseline" });
+
+			try {
+				const pr = parsePrInput(prUrl);
+				const res = await fetch(
+					`https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}`,
+					{ headers: ghHeaders },
+				);
+				if (!res.ok) return json({ outdated: false, reason: "api_error" });
+				const data = await res.json() as { updated_at?: string; title?: string; state?: string; merged?: boolean; draft?: boolean };
+				const currentUpdatedAt = data.updated_at ?? "";
+				const outdated = currentUpdatedAt !== analyzedUpdatedAt;
+				return json({
+					outdated,
+					analyzed_at: sessionData.meta.analyzed_at,
+					analyzed_updated_at: analyzedUpdatedAt,
+					current_updated_at: currentUpdatedAt,
+					current_title: data.title,
+					current_state: data.draft ? "draft" : data.merged ? "merged" : data.state === "closed" ? "closed" : "open",
+				});
+			} catch {
+				return json({ outdated: false, reason: "fetch_error" });
+			}
+		},
+
 		"GET /api/sessions/:id/chat": async (req: Request) => {
 			const url = new URL(req.url);
 			const segments = url.pathname.split("/");
@@ -875,6 +1001,32 @@ $$
 							return `Error: ${err instanceof Error ? err.message : String(err)}`;
 						}
 					}
+					case "run_react_doctor": {
+						const agents = await detectAgents();
+						if (agents.length > 0) {
+							try {
+								const result = await runAgent(
+									agents[0]!,
+									process.cwd(),
+									"Run react-doctor on this project:\n\nnpx -y react-doctor@latest . --verbose\n\nReturn the FULL output including the score and all diagnostics.",
+									{ timeout: 60_000 },
+								);
+								if (result.answer.trim()) return result.answer;
+							} catch {}
+						}
+						try {
+							const proc = Bun.spawn(["npx", "-y", "react-doctor@latest", ".", "--verbose"], {
+								cwd: process.cwd(),
+								stdout: "pipe",
+								stderr: "pipe",
+							});
+							const output = await new Response(proc.stdout).text();
+							const stderr = await new Response(proc.stderr).text();
+							return output.trim() || stderr.trim() || "react-doctor produced no output";
+						} catch (err) {
+							return `Error running react-doctor: ${err instanceof Error ? err.message : String(err)}`;
+						}
+					}
 					case "web_search": {
 						const query = args.query as string;
 						if (!query) return "Error: query argument required";
@@ -1088,5 +1240,75 @@ $$
 				return json({ error: msg }, 500);
 			}
 		},
+		"GET /api/sessions/:id/slides": async (req: Request) => {
+			const url = new URL(req.url);
+			const segments = url.pathname.split("/");
+			const id = segments[3]!;
+			const deck = await loadSlidesSidecar(id);
+			if (!deck) return json(null);
+			return json(deck);
+		},
+
+		"POST /api/slides": async (req: Request) => {
+			if (!config.openrouter_api_key) return json({ error: "OpenRouter API key required" }, 400);
+
+			const body = await req.json() as { sessionId?: string; language?: string; resume?: boolean };
+			const sessionId = body.sessionId;
+			if (!sessionId) return json({ error: "Missing sessionId" }, 400);
+
+			const data = await loadSession(sessionId);
+			if (!data) return json({ error: "Session not found" }, 404);
+
+			if (slideJobs.has(sessionId) && slideJobs.get(sessionId)!.status === "running") {
+				return json({ status: "already_running" });
+			}
+
+			const existingDeck = body.resume ? await loadSlidesSidecar(sessionId) : null;
+			const job: SlideJob = { status: "running", message: "Planning slide deck...", current: 0, total: 0 };
+			slideJobs.set(sessionId, job);
+
+			(async () => {
+				try {
+					const deck = await generateSlides(
+						config.openrouter_api_key,
+						data,
+						config.model,
+						body.language ?? config.language,
+						(msg, current, total) => {
+							job.message = msg;
+							job.current = current;
+							job.total = total;
+						},
+						existingDeck,
+						(plan, prompts) => {
+							job.plan = plan;
+							job.imagePrompts = prompts;
+						},
+						(partialDeck) => {
+							saveSlidesSidecar(sessionId, partialDeck).catch(() => {});
+						},
+					);
+					await saveSlidesSidecar(sessionId, deck);
+					job.status = "done";
+					job.message = `Generated ${deck.slides.length} slides`;
+					job.total = deck.slides.length;
+					job.current = deck.slides.length;
+				} catch (err) {
+					job.status = "error";
+					job.message = err instanceof Error ? err.message : String(err);
+				}
+			})();
+
+			return json({ status: "started" });
+		},
+
+		"GET /api/slides/status": async (req: Request) => {
+			const url = new URL(req.url);
+			const sessionId = url.searchParams.get("sessionId");
+			if (!sessionId) return json({ error: "Missing sessionId" }, 400);
+			const job = slideJobs.get(sessionId);
+			if (!job) return json({ status: "idle" });
+			return json(job);
+		},
 	};
 }

package/src/web/server/session-manager.ts

@@ -9,6 +9,7 @@ type SessionStatus = "running" | "done" | "error" | "canceled";
 
 interface AnalysisSession {
 	id: string;
+	prInput: string;
 	status: SessionStatus;
 	events: ProgressEvent[];
 	result?: NewprOutput;
@@ -16,6 +17,8 @@ interface AnalysisSession {
 	error?: string;
 	startedAt: number;
 	finishedAt?: number;
+	prTitle?: string;
+	prNumber?: number;
 	abortController: AbortController;
 	subscribers: Set<(event: ProgressEvent | { type: "done" | "error"; data?: string }) => void>;
 }
@@ -53,6 +56,7 @@ export function startAnalysis(
 
 	const session: AnalysisSession = {
 		id,
+		prInput,
 		status: "running",
 		events: [],
 		startedAt: Date.now(),
@@ -84,6 +88,8 @@ async function runPipeline(
 			onProgress: (event: ProgressEvent) => {
 				const stamped = { ...event, timestamp: event.timestamp ?? Date.now() };
 				session.events.push(stamped);
+				if (event.pr_title) session.prTitle = event.pr_title;
+				if (event.pr_number) session.prNumber = event.pr_number;
 				for (const sub of session.subscribers) {
 					sub(stamped);
 				}
@@ -129,6 +135,34 @@ export function cancelAnalysis(id: string): boolean {
 	return true;
 }
 
+export function listActiveSessions(): Array<{
+	id: string;
+	prInput: string;
+	status: SessionStatus;
+	startedAt: number;
+	prTitle?: string;
+	prNumber?: number;
+	lastStage?: string;
+	lastMessage?: string;
+}> {
+	const result: ReturnType<typeof listActiveSessions> = [];
+	for (const s of sessions.values()) {
+		if (s.status !== "running") continue;
+		const lastEvent = s.events[s.events.length - 1];
+		result.push({
+			id: s.id,
+			prInput: s.prInput,
+			status: s.status,
+			startedAt: s.startedAt,
+			prTitle: s.prTitle,
+			prNumber: s.prNumber,
+			lastStage: lastEvent?.stage,
+			lastMessage: lastEvent?.message,
+		});
+	}
+	return result;
+}
+
 export function subscribe(
 	id: string,
 	callback: (event: ProgressEvent | { type: "done" | "error"; data?: string }) => void,

package/src/web/server.ts

@@ -4,6 +4,7 @@ import { createRoutes } from "./server/routes.ts";
 import index from "./index.html";
 
 import type { PreflightResult } from "../cli/preflight.ts";
+import { getVersion } from "../version.ts";
 
 interface WebServerOptions {
 	port: number;
@@ -101,6 +102,12 @@ export async function startWebServer(options: WebServerOptions): Promise<void> {
 			if (path.match(/^\/api\/sessions\/[^/]+\/comments$/) && req.method === "POST") {
 				return routes["POST /api/sessions/:id/comments"](req);
 			}
+			if (path.match(/^\/api\/sessions\/[^/]+\/ask-inline$/) && req.method === "POST") {
+				return routes["POST /api/sessions/:id/ask-inline"](req);
+			}
+			if (path.match(/^\/api\/sessions\/[^/]+\/outdated$/) && req.method === "GET") {
+				return routes["GET /api/sessions/:id/outdated"](req);
+			}
 			if (path.match(/^\/api\/sessions\/[^/]+\/chat\/undo$/) && req.method === "POST") {
 				return routes["POST /api/sessions/:id/chat/undo"](req);
 			}
@@ -125,9 +132,21 @@ export async function startWebServer(options: WebServerOptions): Promise<void> {
 			if (path === "/api/preflight" && req.method === "GET") {
 				return routes["GET /api/preflight"]();
 			}
+			if (path === "/api/active-analyses" && req.method === "GET") {
+				return routes["GET /api/active-analyses"]();
+			}
 			if (path === "/api/cartoon" && req.method === "POST") {
 				return routes["POST /api/cartoon"](req);
 			}
+			if (path.match(/^\/api\/sessions\/[^/]+\/slides$/) && req.method === "GET") {
+				return routes["GET /api/sessions/:id/slides"](req);
+			}
+			if (path === "/api/slides" && req.method === "POST") {
+				return routes["POST /api/slides"](req);
+			}
+			if (path === "/api/slides/status" && req.method === "GET") {
+				return routes["GET /api/slides/status"](req);
+			}
 			if (path === "/api/review" && req.method === "POST") {
 				return routes["POST /api/review"](req);
 			}
@@ -148,7 +167,7 @@ export async function startWebServer(options: WebServerOptions): Promise<void> {
 	const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
 
 	console.log("");
-	console.log(`  ${bold("newpr")} ${dim("v0.3.0")}`);
+	console.log(`  ${bold("newpr")} ${dim(`v${getVersion()}`)}`);
 	console.log("");
 	console.log(`  ${dim("→")} Local    ${cyan(url)}`);
 	console.log(`  ${dim("→")} Model    ${dim(config.model)}`);