newpr 0.4.0 → 0.5.1

package/src/web/server/routes.ts

@@ -1,15 +1,17 @@
 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 { readStoredConfig, writeStoredConfig, type StoredConfig } from "../../config/store.ts";
 import { startAnalysis, getSession, cancelAnalysis, subscribe, listActiveSessions } from "./session-manager.ts";
 import { generateCartoon } from "../../llm/cartoon.ts";
+import { generateSlides } from "../../llm/slides.ts";
+import { getPlugin, getAllPlugins } from "../../plugins/registry.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 +72,24 @@ 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>();
+
+	interface PluginJob {
+		status: "running" | "done" | "error";
+		message: string;
+		current: number;
+		total: number;
+	}
+	const pluginJobs = new Map<string, PluginJob>();
+
 	function buildChatSystemPrompt(data: NewprOutput): string {
 		const fileSummaries = data.files
 			.map((f) => `- ${f.path} (${f.status}, +${f.additions}/-${f.deletions}): ${f.summary}`)
@@ -218,12 +238,44 @@ $$
 					},
 				},
 			},
+			{
+				type: "function",
+				function: {
+					name: "create_review_comment",
+					description: "Create an inline review comment on a specific line or line range of a file in this PR. The comment will be posted to GitHub. Use this when the user asks to leave a comment, suggestion, or feedback on specific code.",
+					parameters: {
+						type: "object",
+						properties: {
+							path: { type: "string", description: "File path (e.g. 'src/auth/session.ts')" },
+							line: { type: "number", description: "Line number to comment on (end line if range)" },
+							start_line: { type: "number", description: "Start line for multi-line comment (optional)" },
+							body: { type: "string", description: "Comment body in markdown" },
+						},
+						required: ["path", "line", "body"],
+					},
+				},
+			},
+			{
+				type: "function",
+				function: {
+					name: "submit_review",
+					description: "Submit a PR review with a verdict: APPROVE, REQUEST_CHANGES, or COMMENT. Use when the user asks to approve or request changes on the PR.",
+					parameters: {
+						type: "object",
+						properties: {
+							event: { type: "string", enum: ["APPROVE", "REQUEST_CHANGES", "COMMENT"], description: "Review action" },
+							body: { type: "string", description: "Optional review summary message" },
+						},
+						required: ["event"],
+					},
+				},
+			},
 		];
 	}
 
 	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);
@@ -231,6 +283,7 @@ $$
 
 			return json({
 				sessionId: result.sessionId,
+				reuseSessionId: body.reuseSessionId,
 				eventsUrl: `/api/analysis/${result.sessionId}/events`,
 			});
 		},
@@ -471,7 +524,38 @@ $$
 			}
 		},
 
+		"GET /api/models": async () => {
+			if (!config.openrouter_api_key) return json([]);
+			try {
+				const res = await fetch("https://openrouter.ai/api/v1/models", {
+					headers: { Authorization: `Bearer ${config.openrouter_api_key}` },
+				});
+				if (!res.ok) return json([]);
+				const data = await res.json() as { data?: Array<{ id: string; name: string; created?: number; context_length?: number }> };
+				const models = (data.data ?? [])
+					.filter((m) => m.id && !m.id.includes(":free") && !m.id.includes(":extended"))
+					.map((m) => ({
+						id: m.id,
+						name: m.name ?? m.id,
+						provider: m.id.split("/")[0] ?? "",
+						created: m.created ?? 0,
+						contextLength: m.context_length,
+					}))
+					.sort((a, b) => {
+						const provCmp = a.provider.localeCompare(b.provider);
+						if (provCmp !== 0) return provCmp;
+						return b.created - a.created;
+					});
+				return json(models);
+			} catch {
+				return json([]);
+			}
+		},
+
 		"GET /api/config": async () => {
+			const stored = await readStoredConfig();
+			const pluginList = getAllPlugins().map((p) => ({ id: p.id, name: p.name }));
+			const enabledPlugins = stored.enabled_plugins ?? pluginList.map((p) => p.id);
 			return json({
 				model: config.model,
 				agent: config.agent ?? null,
@@ -481,6 +565,8 @@ $$
 				concurrency: config.concurrency,
 				has_api_key: !!config.openrouter_api_key,
 				has_github_token: !!token,
+				enabled_plugins: enabledPlugins,
+				available_plugins: pluginList,
 				defaults: {
 					model: DEFAULT_CONFIG.model,
 					language: DEFAULT_CONFIG.language,
@@ -528,14 +614,20 @@ $$
 				update.concurrency = body.concurrency;
 				config.concurrency = body.concurrency;
 			}
+			if ((body as Record<string, unknown>).enabled_plugins !== undefined) {
+				update.enabled_plugins = (body as Record<string, unknown>).enabled_plugins as string[];
+			}
 
 			await writeStoredConfig(update);
 			return json({ ok: true });
 		},
 
-		"GET /api/features": () => {
+		"GET /api/features": async () => {
 			const { getVersion } = require("../../version.ts");
-			return json({ cartoon: !!options.cartoon, version: getVersion() });
+			const stored = await readStoredConfig();
+			const allPluginIds = getAllPlugins().map((p) => p.id);
+			const enabledPlugins = stored.enabled_plugins ?? allPluginIds;
+			return json({ cartoon: !!options.cartoon, version: getVersion(), enabledPlugins });
 		},
 
 		"POST /api/review": async (req: Request) => {
@@ -726,6 +818,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("/");
@@ -983,6 +1176,67 @@ $$
 							return `Fetch error: ${err instanceof Error ? err.message : String(err)}`;
 						}
 					}
+					case "create_review_comment": {
+						const filePath = args.path as string;
+						const line = args.line as number;
+						const startLine = args.start_line as number | undefined;
+						const body = args.body as string;
+						if (!filePath || !line || !body) return "Error: path, line, and body are required";
+						try {
+							const pr = parsePrInput(sessionData.meta.pr_url);
+							const sha = await fetchHeadSha(pr);
+							if (!sha) return "Error: could not determine HEAD SHA";
+							const ghBody: Record<string, unknown> = {
+								commit_id: sha,
+								path: filePath,
+								line,
+								side: "RIGHT",
+								body,
+							};
+							if (startLine && startLine !== line) {
+								ghBody.start_line = startLine;
+								ghBody.start_side = "RIGHT";
+							}
+							const res = await fetch(
+								`https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}/comments`,
+								{ method: "POST", headers: ghHeaders, body: JSON.stringify(ghBody) },
+							);
+							if (!res.ok) {
+								const errBody = await res.text();
+								return `GitHub API error ${res.status}: ${errBody.slice(0, 200)}`;
+							}
+							const data = await res.json() as { id?: number; html_url?: string };
+							return `Comment created on ${filePath}:${startLine && startLine !== line ? `${startLine}-` : ""}${line}. ${data.html_url ?? ""}`;
+						} catch (err) {
+							return `Error: ${err instanceof Error ? err.message : String(err)}`;
+						}
+					}
+					case "submit_review": {
+						const event = args.event as string;
+						const body = (args.body as string) ?? "";
+						if (!event || !["APPROVE", "REQUEST_CHANGES", "COMMENT"].includes(event)) {
+							return "Error: event must be APPROVE, REQUEST_CHANGES, or COMMENT";
+						}
+						try {
+							const pr = parsePrInput(sessionData.meta.pr_url);
+							const res = await fetch(
+								`https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}/reviews`,
+								{
+									method: "POST",
+									headers: ghHeaders,
+									body: JSON.stringify({ body, event }),
+								},
+							);
+							if (!res.ok) {
+								const errBody = await res.text();
+								return `GitHub API error ${res.status}: ${errBody.slice(0, 200)}`;
+							}
+							const data = await res.json() as { html_url?: string; state?: string };
+							return `Review submitted: ${data.state ?? event}. ${data.html_url ?? ""}`;
+						} catch (err) {
+							return `Error: ${err instanceof Error ? err.message : String(err)}`;
+						}
+					}
 					default:
 						return `Unknown tool: ${name}`;
 				}
@@ -1127,5 +1381,153 @@ $$
 				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);
+		},
+
+		"GET /api/plugins": () => {
+			const plugins = getAllPlugins().map((p) => ({
+				id: p.id,
+				name: p.name,
+				description: p.description,
+				icon: p.icon,
+				tabLabel: p.tabLabel,
+			}));
+			return json(plugins);
+		},
+
+		"GET /api/plugins/:id/data": async (req: Request) => {
+			const url = new URL(req.url);
+			const segments = url.pathname.split("/");
+			const pluginId = segments[3]!;
+			const sessionId = url.searchParams.get("sessionId");
+			if (!sessionId) return json({ error: "Missing sessionId" }, 400);
+			const plugin = getPlugin(pluginId);
+			if (!plugin) return json({ error: `Unknown plugin: ${pluginId}` }, 404);
+			const data = await plugin.load(sessionId);
+			return json(data);
+		},
+
+		"POST /api/plugins/:id/generate": async (req: Request) => {
+			const url = new URL(req.url);
+			const segments = url.pathname.split("/");
+			const pluginId = segments[3]!;
+			const body = await req.json() as { sessionId?: string; resume?: boolean };
+			const sessionId = body.sessionId;
+			if (!sessionId) return json({ error: "Missing sessionId" }, 400);
+			if (!config.openrouter_api_key) return json({ error: "API key required" }, 400);
+
+			const plugin = getPlugin(pluginId);
+			if (!plugin) return json({ error: `Unknown plugin: ${pluginId}` }, 404);
+
+			const data = await loadSession(sessionId);
+			if (!data) return json({ error: "Session not found" }, 404);
+
+			const jobKey = `${pluginId}:${sessionId}`;
+			if (pluginJobs.has(jobKey) && pluginJobs.get(jobKey)!.status === "running") {
+				return json({ status: "already_running" });
+			}
+
+			const job: PluginJob = { status: "running", message: "Starting...", current: 0, total: 0 };
+			pluginJobs.set(jobKey, job);
+
+			const existingData = body.resume ? await plugin.load(sessionId) : null;
+
+			(async () => {
+				try {
+					const result = await plugin.generate(
+						{ apiKey: config.openrouter_api_key, sessionId, data, language: config.language },
+						(event) => { job.message = event.message; job.current = event.current; job.total = event.total; },
+						existingData,
+					);
+					await plugin.save(sessionId, result.data);
+					job.status = "done";
+					job.message = "Complete";
+				} catch (err) {
+					job.status = "error";
+					job.message = err instanceof Error ? err.message : String(err);
+				}
+			})();
+
+			return json({ status: "started" });
+		},
+
+		"GET /api/plugins/:id/status": async (req: Request) => {
+			const url = new URL(req.url);
+			const segments = url.pathname.split("/");
+			const pluginId = segments[3]!;
+			const sessionId = url.searchParams.get("sessionId");
+			if (!sessionId) return json({ error: "Missing sessionId" }, 400);
+			const job = pluginJobs.get(`${pluginId}:${sessionId}`);
+			if (!job) return json({ status: "idle" });
+			return json(job);
+		},
 	};
 }

package/src/web/server.ts

@@ -70,6 +70,9 @@ export async function startWebServer(options: WebServerOptions): Promise<void> {
 				GET: routes["GET /api/config"],
 				PUT: routes["PUT /api/config"],
 			},
+			"/api/models": {
+				GET: routes["GET /api/models"],
+			},
 		},
 		fetch(req) {
 			const url = new URL(req.url);
@@ -102,6 +105,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);
 			}
@@ -132,6 +141,27 @@ export async function startWebServer(options: WebServerOptions): Promise<void> {
 			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/plugins" && req.method === "GET") {
+				return routes["GET /api/plugins"]();
+			}
+			if (path.match(/^\/api\/plugins\/[^/]+\/data$/) && req.method === "GET") {
+				return routes["GET /api/plugins/:id/data"](req);
+			}
+			if (path.match(/^\/api\/plugins\/[^/]+\/generate$/) && req.method === "POST") {
+				return routes["POST /api/plugins/:id/generate"](req);
+			}
+			if (path.match(/^\/api\/plugins\/[^/]+\/status$/) && req.method === "GET") {
+				return routes["GET /api/plugins/:id/status"](req);
+			}
 			if (path === "/api/review" && req.method === "POST") {
 				return routes["POST /api/review"](req);
 			}