newpr 0.1.0

package/src/web/server.ts

@@ -0,0 +1,96 @@
+import { join, dirname } from "node:path";
+import type { NewprConfig } from "../types/config.ts";
+import { createRoutes } from "./server/routes.ts";
+import index from "./index.html";
+
+interface WebServerOptions {
+	port: number;
+	token: string;
+	config: NewprConfig;
+}
+
+function getCssPaths() {
+	const webDir = dirname(Bun.resolveSync("./src/web/index.html", process.cwd()));
+	return {
+		input: join(webDir, "styles", "globals.css"),
+		output: join(webDir, "styles", "built.css"),
+		bin: join(process.cwd(), "node_modules", ".bin", "tailwindcss"),
+	};
+}
+
+async function buildCss(bin: string, input: string, output: string): Promise<void> {
+	const proc = Bun.spawn(
+		[bin, "-i", input, "-o", output, "--minify"],
+		{ cwd: process.cwd(), stderr: "pipe", stdout: "pipe" },
+	);
+	const exitCode = await proc.exited;
+	if (exitCode !== 0) {
+		const stderr = await new Response(proc.stderr).text();
+		throw new Error(`Tailwind CSS build failed (exit ${exitCode}): ${stderr}`);
+	}
+}
+
+export async function startWebServer(options: WebServerOptions): Promise<void> {
+	const { port, token, config } = options;
+	const routes = createRoutes(token, config);
+	const css = getCssPaths();
+
+	await buildCss(css.bin, css.input, css.output);
+
+	const server = Bun.serve({
+		port,
+		hostname: "127.0.0.1",
+		routes: {
+			"/": index,
+			"/styles.css": async () => {
+				await buildCss(css.bin, css.input, css.output);
+				const file = Bun.file(css.output);
+				return new Response(file, {
+					headers: {
+						"content-type": "text/css; charset=utf-8",
+						"cache-control": "no-cache, no-store, must-revalidate",
+					},
+				});
+			},
+			"/api/analysis": {
+				POST: routes["POST /api/analysis"],
+			},
+			"/api/sessions": {
+				GET: routes["GET /api/sessions"],
+			},
+			"/api/me": {
+				GET: routes["GET /api/me"],
+			},
+			"/api/config": {
+				GET: routes["GET /api/config"],
+				PUT: routes["PUT /api/config"],
+			},
+		},
+		fetch(req) {
+			const url = new URL(req.url);
+			const path = url.pathname;
+
+			if (path.match(/^\/api\/analysis\/[^/]+\/events$/) && req.method === "GET") {
+				return routes["GET /api/analysis/:id/events"](req);
+			}
+			if (path.match(/^\/api\/analysis\/[^/]+\/cancel$/) && req.method === "POST") {
+				return routes["POST /api/analysis/:id/cancel"](req);
+			}
+			if (path.match(/^\/api\/analysis\/[^/]+$/) && req.method === "GET") {
+				return routes["GET /api/analysis/:id"](req);
+			}
+			if (path.match(/^\/api\/sessions\/[^/]+$/) && req.method === "GET") {
+				return routes["GET /api/sessions/:id"](req);
+			}
+
+			return new Response("Not Found", { status: 404 });
+		},
+		development: {
+			hmr: true,
+			console: true,
+		},
+	});
+
+	console.log(`\n  newpr web UI`);
+	console.log(`  Local:   http://localhost:${server.port}\n`);
+}

package/src/web/styles/globals.css

@@ -0,0 +1,91 @@
+@import "tailwindcss";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+	--color-background: var(--bg);
+	--color-foreground: var(--fg);
+	--color-card: var(--card);
+	--color-card-foreground: var(--card-fg);
+	--color-popover: var(--popover);
+	--color-popover-foreground: var(--popover-fg);
+	--color-primary: var(--primary);
+	--color-primary-foreground: var(--primary-fg);
+	--color-secondary: var(--secondary);
+	--color-secondary-foreground: var(--secondary-fg);
+	--color-muted: var(--muted);
+	--color-muted-foreground: var(--muted-fg);
+	--color-accent: var(--accent);
+	--color-accent-foreground: var(--accent-fg);
+	--color-destructive: var(--destructive);
+	--color-destructive-foreground: var(--destructive-fg);
+	--color-border: var(--border);
+	--color-input: var(--input);
+	--color-ring: var(--ring);
+	--color-success: hsl(142, 71%, 45%);
+	--color-warning: hsl(38, 92%, 50%);
+	--color-info: hsl(217, 91%, 60%);
+}
+
+@theme {
+	--radius: 0.5rem;
+	--font-sans: "Pretendard", "Inter", ui-sans-serif, system-ui, sans-serif;
+	--font-mono: "JetBrains Mono", ui-monospace, monospace;
+}
+
+:root {
+	--bg: #ffffff;
+	--fg: #0a0a0a;
+	--card: #ffffff;
+	--card-fg: #0a0a0a;
+	--popover: #ffffff;
+	--popover-fg: #0a0a0a;
+	--primary: #171717;
+	--primary-fg: #fafafa;
+	--secondary: #f5f5f5;
+	--secondary-fg: #171717;
+	--muted: #f5f5f5;
+	--muted-fg: #737373;
+	--accent: #f5f5f5;
+	--accent-fg: #171717;
+	--destructive: #ef4444;
+	--destructive-fg: #fafafa;
+	--border: #e5e5e5;
+	--input: #e5e5e5;
+	--ring: #0a0a0a;
+}
+
+.dark {
+	--bg: #0a0a0a;
+	--fg: #fafafa;
+	--card: #0a0a0a;
+	--card-fg: #fafafa;
+	--popover: #0a0a0a;
+	--popover-fg: #fafafa;
+	--primary: #fafafa;
+	--primary-fg: #171717;
+	--secondary: #262626;
+	--secondary-fg: #fafafa;
+	--muted: #262626;
+	--muted-fg: #a3a3a3;
+	--accent: #262626;
+	--accent-fg: #fafafa;
+	--destructive: #7f1d1d;
+	--destructive-fg: #fafafa;
+	--border: #262626;
+	--input: #262626;
+	--ring: #d4d4d4;
+}
+
+@layer base {
+	* {
+		border-color: var(--border);
+	}
+	body {
+		background-color: var(--bg);
+		color: var(--fg);
+		font-feature-settings: "rlig" 1, "calt" 1;
+		-webkit-font-smoothing: antialiased;
+		-moz-osx-font-smoothing: grayscale;
+	}
+}

package/src/workspace/agent.ts

@@ -0,0 +1,317 @@
+import type { AgentTool, AgentToolName, AgentResult } from "./types.ts";
+import { INSTALL_INSTRUCTIONS } from "./types.ts";
+
+const AGENT_PRIORITY: AgentToolName[] = ["claude", "opencode", "codex"];
+
+const DETECTION_COMMANDS: Record<AgentToolName, string> = {
+	claude: "claude",
+	opencode: "opencode",
+	codex: "codex",
+};
+
+async function which(cmd: string): Promise<string | null> {
+	try {
+		const result = await Bun.$`which ${cmd}`.text();
+		const path = result.trim();
+		return path || null;
+	} catch {
+		return null;
+	}
+}
+
+export async function detectAgents(): Promise<AgentTool[]> {
+	const agents: AgentTool[] = [];
+
+	for (const name of AGENT_PRIORITY) {
+		const path = await which(DETECTION_COMMANDS[name]);
+		if (path) {
+			agents.push({ name, path });
+		}
+	}
+
+	return agents;
+}
+
+export async function requireAgent(preferred?: AgentToolName): Promise<AgentTool> {
+	const agents = await detectAgents();
+
+	if (preferred) {
+		const found = agents.find((a) => a.name === preferred);
+		if (found) return found;
+
+		const instruction = INSTALL_INSTRUCTIONS[preferred];
+		throw new Error(
+			`Agent "${preferred}" is not installed.\n\n` +
+			`Install it with:\n  ${instruction}\n\n` +
+			`Or use one of these available agents: ${agents.map((a) => a.name).join(", ") || "(none installed)"}`,
+		);
+	}
+
+	if (agents.length > 0) {
+		return agents[0]!;
+	}
+
+	const installList = AGENT_PRIORITY
+		.map((name) => `  ${name}: ${INSTALL_INSTRUCTIONS[name]}`)
+		.join("\n");
+
+	throw new Error(
+		"No agentic coding tool found.\n\n" +
+		"newpr requires at least one of the following tools for codebase exploration:\n\n" +
+		`${installList}\n\n` +
+		"Install any one of them and try again.",
+	);
+}
+
+interface RunOptions {
+	timeout?: number;
+	allowedTools?: string[];
+	onOutput?: (line: string) => void;
+}
+
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+
+function stripAnsi(text: string): string {
+	return text.replace(ANSI_RE, "");
+}
+
+async function streamLines(
+	stream: ReadableStream<Uint8Array>,
+	onLine: (line: string) => void,
+): Promise<void> {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+
+	for (;;) {
+		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 raw of lines) {
+			const line = stripAnsi(raw).trim();
+			if (line) onLine(line);
+		}
+	}
+
+	const tail = stripAnsi(buffer).trim();
+	if (tail) onLine(tail);
+}
+
+const TOOL_LABELS: Record<string, (input: Record<string, unknown>) => string> = {
+	Read: (i) => `Reading ${truncPath(i.file_path as string ?? i.filePath as string ?? "")}`,
+	Glob: (i) => `Glob ${i.pattern as string ?? ""}`,
+	Grep: (i) => `Grep "${i.pattern as string ?? ""}"`,
+	Bash: (i) => {
+		const cmd = (i.command as string ?? "").slice(0, 60);
+		return `$ ${cmd}`;
+	},
+	ListFiles: (i) => `Listing ${truncPath(i.path as string ?? ".")}`,
+	Search: (i) => `Search "${i.query as string ?? ""}"`,
+};
+
+function truncPath(p: string): string {
+	if (p.length <= 50) return p;
+	const parts = p.split("/");
+	if (parts.length <= 3) return `…${p.slice(-47)}`;
+	return `${parts[0]}/…/${parts.slice(-2).join("/")}`;
+}
+
+function formatToolUse(name: string, input: Record<string, unknown>): string | null {
+	const formatter = TOOL_LABELS[name];
+	if (formatter) return formatter(input);
+	return `${name}`;
+}
+
+export async function runAgent(
+	agent: AgentTool,
+	workdir: string,
+	prompt: string,
+	options?: RunOptions,
+): Promise<AgentResult> {
+	const timeout = options?.timeout ?? 60_000;
+
+	switch (agent.name) {
+		case "claude":
+			return runClaude(agent, workdir, prompt, timeout, options?.onOutput);
+		case "opencode":
+			return runOpencode(agent, workdir, prompt, timeout, options?.onOutput);
+		case "codex":
+			return runCodex(agent, workdir, prompt, timeout, options?.onOutput);
+	}
+}
+
+async function runClaude(
+	agent: AgentTool,
+	workdir: string,
+	prompt: string,
+	timeout: number,
+	onOutput?: (line: string) => void,
+): Promise<AgentResult> {
+	const start = Date.now();
+	const proc = Bun.spawn(
+		[
+			agent.path,
+			"-p",
+			"--output-format", "stream-json",
+			"--permission-mode", "bypassPermissions",
+			"--allowedTools", "Read", "Glob", "Grep", "Bash(find:*)", "Bash(wc:*)", "Bash(head:*)",
+			prompt,
+		],
+		{
+			cwd: workdir,
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "ignore",
+		},
+	);
+
+	let answer = "";
+	let costUsd: number | undefined;
+
+	const stdoutPromise = proc.stdout
+		? streamLines(proc.stdout, (line) => {
+			try {
+				const event = JSON.parse(line);
+				if (event.type === "assistant" && event.message?.content) {
+					for (const block of event.message.content) {
+						if (block.type === "tool_use" && onOutput) {
+							const label = formatToolUse(
+								block.name ?? "",
+								(block.input as Record<string, unknown>) ?? {},
+							);
+							if (label) onOutput(label);
+						}
+					}
+				} else if (event.type === "result") {
+					answer = event.result ?? "";
+					costUsd = event.cost_usd ?? event.total_cost_usd;
+				}
+			} catch {
+			}
+		})
+		: Promise.resolve();
+
+	const timeoutId = setTimeout(() => proc.kill(), timeout);
+	await stdoutPromise;
+	clearTimeout(timeoutId);
+
+	const duration = Date.now() - start;
+
+	return {
+		answer,
+		cost_usd: costUsd,
+		duration_ms: duration,
+		tool_used: agent.name,
+	};
+}
+
+async function runOpencode(
+	agent: AgentTool,
+	workdir: string,
+	prompt: string,
+	timeout: number,
+	onOutput?: (line: string) => void,
+): Promise<AgentResult> {
+	const start = Date.now();
+	const proc = Bun.spawn(
+		[agent.path, workdir, "run", "--format", "json", prompt],
+		{
+			cwd: workdir,
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
+		},
+	);
+
+	const stderrPromise = onOutput && proc.stderr
+		? streamLines(proc.stderr, onOutput)
+		: Promise.resolve();
+
+	const timeoutId = setTimeout(() => proc.kill(), timeout);
+	const output = await new Response(proc.stdout).text();
+	await stderrPromise;
+	clearTimeout(timeoutId);
+
+	const duration = Date.now() - start;
+
+	const lines = output.trim().split("\n");
+	const lastLine = lines[lines.length - 1] ?? "";
+	try {
+		const json = JSON.parse(lastLine);
+		return {
+			answer: json.content ?? json.text ?? lastLine,
+			duration_ms: duration,
+			tool_used: agent.name,
+		};
+	} catch {
+		return {
+			answer: output.trim(),
+			duration_ms: duration,
+			tool_used: agent.name,
+		};
+	}
+}
+
+async function runCodex(
+	agent: AgentTool,
+	workdir: string,
+	prompt: string,
+	timeout: number,
+	onOutput?: (line: string) => void,
+): Promise<AgentResult> {
+	const start = Date.now();
+	const proc = Bun.spawn(
+		[
+			agent.path, "exec",
+			"--json",
+			"--dangerously-bypass-approvals-and-sandbox",
+			"-C", workdir,
+			prompt,
+		],
+		{
+			cwd: workdir,
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "ignore",
+		},
+	);
+
+	let answer = "";
+
+	const stdoutPromise = proc.stdout
+		? streamLines(proc.stdout, (line) => {
+			try {
+				const event = JSON.parse(line);
+				if (event.type === "item.completed" && event.item) {
+					if (event.item.type === "tool_call" && onOutput) {
+						const name = event.item.name ?? event.item.tool ?? "";
+						const args = event.item.arguments ?? event.item.input ?? {};
+						const parsed = typeof args === "string" ? JSON.parse(args) : args;
+						const label = formatToolUse(name, parsed as Record<string, unknown>);
+						if (label) onOutput(label);
+					}
+					if (event.item.type === "agent_message" && event.item.text) {
+						answer = event.item.text;
+					}
+				}
+			} catch {
+			}
+		})
+		: Promise.resolve();
+
+	const timeoutId = setTimeout(() => proc.kill(), timeout);
+	await stdoutPromise;
+	clearTimeout(timeoutId);
+
+	const duration = Date.now() - start;
+
+	return {
+		answer,
+		duration_ms: duration,
+		tool_used: agent.name,
+	};
+}

package/src/workspace/explore.ts

@@ -0,0 +1,82 @@
+import type { AgentTool } from "./types.ts";
+import type { ExplorationResult } from "./types.ts";
+import { runAgent } from "./agent.ts";
+
+const STRUCTURE_PROMPT = `Analyze the project structure of this repository concisely.
+Return:
+1. What kind of project this is (language, framework, purpose)
+2. The key directories and what they contain
+3. Important config files and what they indicate
+4. The overall architecture pattern (monorepo, MVC, microservices, etc.)
+Keep it under 500 words. Focus on facts, not opinions.`;
+
+function buildRelatedCodePrompt(changedFiles: string[], prTitle: string): string {
+	const fileList = changedFiles.slice(0, 30).join("\n  ");
+	return `These files were changed in a PR titled "${prTitle}":
+  ${fileList}
+
+For each changed file, find:
+1. What imports it / what it imports (direct dependencies)
+2. Key functions or classes it defines and where they are used
+3. Any tests that cover this file
+
+Be concise. Focus on the most important relationships. Under 800 words total.`;
+}
+
+function buildIssuesPrompt(changedFiles: string[], diff: string): string {
+	const truncatedDiff = diff.length > 12000 ? `${diff.slice(0, 12000)}\n\n... (diff truncated)` : diff;
+	return `Review this PR diff for potential issues. The changed files are:
+${changedFiles.slice(0, 20).join(", ")}
+
+Diff:
+\`\`\`
+${truncatedDiff}
+\`\`\`
+
+Look at the actual codebase (not just the diff) to check:
+1. Are there breaking changes to public APIs that callers depend on?
+2. Are there missing error handling patterns that the rest of the codebase uses?
+3. Are there inconsistencies with existing code patterns/conventions?
+4. Are there missing test updates for changed functionality?
+
+Only report real issues you can verify from the codebase. No speculation. Under 600 words.`;
+}
+
+const PHASE_LABELS = ["Analyzing project structure", "Finding related code", "Checking for issues"] as const;
+
+export async function exploreCodebase(
+	agent: AgentTool,
+	headPath: string,
+	changedFiles: string[],
+	prTitle: string,
+	diff: string,
+	onProgress?: (msg: string, current?: number, total?: number) => void,
+): Promise<ExplorationResult> {
+	const timeout = 90_000;
+
+	onProgress?.(`${PHASE_LABELS[0]}...`, 1, 3);
+	const structureResult = await runAgent(agent, headPath, STRUCTURE_PROMPT, {
+		timeout,
+		onOutput: (line) => onProgress?.(`[1/3] ${line}`, 1, 3),
+	});
+
+	onProgress?.(`${PHASE_LABELS[1]}...`, 2, 3);
+	const relatedPrompt = buildRelatedCodePrompt(changedFiles, prTitle);
+	const relatedResult = await runAgent(agent, headPath, relatedPrompt, {
+		timeout,
+		onOutput: (line) => onProgress?.(`[2/3] ${line}`, 2, 3),
+	});
+
+	onProgress?.(`${PHASE_LABELS[2]}...`, 3, 3);
+	const issuesPrompt = buildIssuesPrompt(changedFiles, diff);
+	const issuesResult = await runAgent(agent, headPath, issuesPrompt, {
+		timeout,
+		onOutput: (line) => onProgress?.(`[3/3] ${line}`, 3, 3),
+	});
+
+	return {
+		project_structure: structureResult.answer,
+		related_code: relatedResult.answer,
+		potential_issues: issuesResult.answer,
+	};
+}

package/src/workspace/repo-cache.ts

@@ -0,0 +1,69 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+
+const REPOS_DIR = join(homedir(), ".newpr", "repos");
+const FETCH_COOLDOWN_MS = 5 * 60 * 1000;
+
+function bareRepoPath(owner: string, repo: string): string {
+	return join(REPOS_DIR, "github.com", owner, `${repo}.git`);
+}
+
+function stampPath(repoPath: string): string {
+	return join(repoPath, ".newpr-fetched");
+}
+
+function needsFetch(repoPath: string): boolean {
+	const stamp = stampPath(repoPath);
+	if (!existsSync(stamp)) return true;
+	try {
+		const ts = Number(readFileSync(stamp, "utf-8").trim());
+		return Date.now() - ts > FETCH_COOLDOWN_MS;
+	} catch {
+		return true;
+	}
+}
+
+function touchFetchStamp(repoPath: string): void {
+	writeFileSync(stampPath(repoPath), String(Date.now()));
+}
+
+export async function ensureRepo(
+	owner: string,
+	repo: string,
+	token: string,
+	onProgress?: (msg: string) => void,
+): Promise<string> {
+	const repoPath = bareRepoPath(owner, repo);
+
+	if (existsSync(join(repoPath, "HEAD"))) {
+		if (needsFetch(repoPath)) {
+			onProgress?.("Fetching latest changes...");
+			const fetch = await Bun.$`git -C ${repoPath} fetch --all --prune`.quiet().nothrow();
+			if (fetch.exitCode !== 0) {
+				throw new Error(`git fetch failed (exit ${fetch.exitCode}): ${fetch.stderr.toString().trim()}`);
+			}
+			touchFetchStamp(repoPath);
+		} else {
+			onProgress?.("Repository cache is fresh.");
+		}
+		return repoPath;
+	}
+
+	const parentDir = join(repoPath, "..");
+	mkdirSync(parentDir, { recursive: true });
+
+	const cloneUrl = `https://x-access-token:${token}@github.com/${owner}/${repo}.git`;
+	onProgress?.(`Cloning ${owner}/${repo}...`);
+	const clone = await Bun.$`git clone --bare ${cloneUrl} ${repoPath}`.quiet().nothrow();
+	if (clone.exitCode !== 0) {
+		throw new Error(`git clone failed (exit ${clone.exitCode}): ${clone.stderr.toString().trim()}`);
+	}
+	touchFetchStamp(repoPath);
+
+	return repoPath;
+}
+
+export function getReposDir(): string {
+	return REPOS_DIR;
+}

package/src/workspace/types.ts

@@ -0,0 +1,30 @@
+export type AgentToolName = "claude" | "opencode" | "codex";
+
+export interface AgentTool {
+	name: AgentToolName;
+	path: string;
+}
+
+export interface AgentResult {
+	answer: string;
+	cost_usd?: number;
+	duration_ms: number;
+	tool_used: AgentToolName;
+}
+
+export interface WorktreeSet {
+	basePath: string;
+	headPath: string;
+}
+
+export interface ExplorationResult {
+	project_structure: string;
+	related_code: string;
+	potential_issues: string;
+}
+
+export const INSTALL_INSTRUCTIONS: Record<AgentToolName, string> = {
+	claude: "npm install -g @anthropic-ai/claude-code",
+	opencode: "npm install -g opencode",
+	codex: "npm install -g @openai/codex",
+};