newpr 0.1.0

package/src/diff/chunker.ts

@@ -0,0 +1,30 @@
+import type { DiffChunk, ParsedDiff } from "../types/diff.ts";
+
+const DEFAULT_MAX_TOKENS = 8000;
+
+function estimateTokens(text: string): number {
+	return Math.ceil(text.length / 4);
+}
+
+export function chunkDiff(parsed: ParsedDiff, maxTokensPerChunk = DEFAULT_MAX_TOKENS): DiffChunk[] {
+	return parsed.files.map((file) => {
+		let diffContent = file.raw;
+		let tokens = estimateTokens(diffContent);
+
+		if (tokens > maxTokensPerChunk) {
+			const maxChars = maxTokensPerChunk * 4;
+			diffContent = `${diffContent.slice(0, maxChars)}\n\n... [truncated: ${tokens} estimated tokens, limit ${maxTokensPerChunk}]`;
+			tokens = estimateTokens(diffContent);
+		}
+
+		return {
+			file_path: file.path,
+			status: file.status,
+			additions: file.additions,
+			deletions: file.deletions,
+			is_binary: file.is_binary,
+			diff_content: diffContent,
+			estimated_tokens: tokens,
+		};
+	});
+}

package/src/diff/parser.ts

@@ -0,0 +1,116 @@
+import type { DiffHunk, FileDiff, ParsedDiff } from "../types/diff.ts";
+import type { FileStatus } from "../types/output.ts";
+
+function detectStatus(headerLines: string[]): FileStatus {
+	for (const line of headerLines) {
+		if (line.startsWith("new file mode")) return "added";
+		if (line.startsWith("deleted file mode")) return "deleted";
+		if (line.startsWith("rename from") || line.startsWith("rename to")) return "renamed";
+	}
+	return "modified";
+}
+
+function extractPaths(
+	headerLines: string[],
+	diffLine: string,
+): { path: string; oldPath: string | null } {
+	const diffMatch = diffLine.match(/^diff --git a\/(.+?) b\/(.+)$/);
+	const aPath = diffMatch?.[1] ?? "";
+	const bPath = diffMatch?.[2] ?? "";
+
+	let renameTo: string | null = null;
+	let renameFrom: string | null = null;
+	for (const line of headerLines) {
+		if (line.startsWith("rename from ")) renameFrom = line.slice("rename from ".length);
+		if (line.startsWith("rename to ")) renameTo = line.slice("rename to ".length);
+	}
+
+	if (renameTo) {
+		return { path: renameTo, oldPath: renameFrom };
+	}
+	return { path: bPath || aPath, oldPath: aPath !== bPath ? aPath : null };
+}
+
+function parseHunks(lines: string[]): { hunks: DiffHunk[]; additions: number; deletions: number } {
+	const hunks: DiffHunk[] = [];
+	let additions = 0;
+	let deletions = 0;
+	let currentHunk: { old_start: number; old_count: number; new_start: number; new_count: number; lines: string[] } | null = null;
+
+	for (const line of lines) {
+		const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+		if (hunkMatch) {
+			if (currentHunk) {
+				hunks.push({ ...currentHunk, content: currentHunk.lines.join("\n") });
+			}
+			currentHunk = {
+				old_start: Number(hunkMatch[1]),
+				old_count: Number(hunkMatch[2] ?? "1"),
+				new_start: Number(hunkMatch[3]),
+				new_count: Number(hunkMatch[4] ?? "1"),
+				lines: [line],
+			};
+			continue;
+		}
+
+		if (currentHunk) {
+			currentHunk.lines.push(line);
+			if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+			if (line.startsWith("-") && !line.startsWith("---")) deletions++;
+		}
+	}
+
+	if (currentHunk) {
+		hunks.push({ ...currentHunk, content: currentHunk.lines.join("\n") });
+	}
+
+	return { hunks, additions, deletions };
+}
+
+export function parseDiff(rawDiff: string): ParsedDiff {
+	if (!rawDiff.trim()) {
+		return { files: [], total_additions: 0, total_deletions: 0 };
+	}
+
+	const files: FileDiff[] = [];
+	const fileSections = rawDiff.split(/(?=^diff --git )/m);
+
+	for (const section of fileSections) {
+		if (!section.startsWith("diff --git ")) continue;
+
+		const lines = section.split("\n");
+		const diffLine = lines[0]!;
+
+		const headerEndIdx = lines.findIndex(
+			(l, i) => i > 0 && (l.startsWith("@@") || l.startsWith("Binary")),
+		);
+		const headerLines = headerEndIdx > 0 ? lines.slice(1, headerEndIdx) : lines.slice(1);
+
+		const isBinary =
+			lines.some((l) => l.startsWith("Binary files") || l.includes("GIT binary patch"));
+
+		const status = detectStatus(headerLines);
+		const { path, oldPath } = extractPaths(headerLines, diffLine);
+
+		const bodyLines = headerEndIdx > 0 ? lines.slice(headerEndIdx) : [];
+		const { hunks, additions, deletions } = isBinary
+			? { hunks: [], additions: 0, deletions: 0 }
+			: parseHunks(bodyLines);
+
+		files.push({
+			path,
+			old_path: oldPath,
+			status,
+			additions,
+			deletions,
+			is_binary: isBinary,
+			hunks,
+			raw: section,
+		});
+	}
+
+	const total_additions = files.reduce((sum, f) => sum + f.additions, 0);
+	const total_deletions = files.reduce((sum, f) => sum + f.deletions, 0);
+
+	return { files, total_additions, total_deletions };
+}

package/src/diff/stats.ts

@@ -0,0 +1,37 @@
+import type { ParsedDiff } from "../types/diff.ts";
+import type { FileStatus } from "../types/output.ts";
+
+export interface DiffStats {
+	total_files: number;
+	total_additions: number;
+	total_deletions: number;
+	files_by_status: Record<FileStatus, number>;
+	largest_file: { path: string; changes: number } | null;
+}
+
+export function extractDiffStats(parsed: ParsedDiff): DiffStats {
+	const filesByStatus: Record<FileStatus, number> = {
+		added: 0,
+		modified: 0,
+		deleted: 0,
+		renamed: 0,
+	};
+
+	let largest: { path: string; changes: number } | null = null;
+
+	for (const file of parsed.files) {
+		filesByStatus[file.status]++;
+		const changes = file.additions + file.deletions;
+		if (!largest || changes > largest.changes) {
+			largest = { path: file.path, changes };
+		}
+	}
+
+	return {
+		total_files: parsed.files.length,
+		total_additions: parsed.total_additions,
+		total_deletions: parsed.total_deletions,
+		files_by_status: filesByStatus,
+		largest_file: largest,
+	};
+}

package/src/github/auth.ts

@@ -0,0 +1,16 @@
+export async function getGithubToken(): Promise<string> {
+	const envToken = process.env.GITHUB_TOKEN;
+	if (envToken) return envToken;
+
+	try {
+		const result = await Bun.$`gh auth token`.text();
+		const token = result.trim();
+		if (token) return token;
+	} catch {
+		// intentionally empty: fall through to error below
+	}
+
+	throw new Error(
+		"GitHub token not found. Either set GITHUB_TOKEN env var or run `gh auth login`.",
+	);
+}

package/src/github/fetch-diff.ts

@@ -0,0 +1,24 @@
+import type { PrIdentifier } from "../types/github.ts";
+
+export async function fetchPrDiff(pr: PrIdentifier, token: string): Promise<string> {
+	const url = `https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}`;
+	const response = await fetch(url, {
+		headers: {
+			Authorization: `token ${token}`,
+			Accept: "application/vnd.github.v3.diff",
+			"User-Agent": "newpr-cli",
+		},
+	});
+
+	if (response.status === 404) {
+		throw new Error(`PR not found: ${pr.owner}/${pr.repo}#${pr.number}`);
+	}
+	if (response.status === 401 || response.status === 403) {
+		throw new Error(`GitHub authentication failed. Check your token permissions.`);
+	}
+	if (!response.ok) {
+		throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+	}
+
+	return response.text();
+}

package/src/github/fetch-pr.ts

@@ -0,0 +1,90 @@
+import type { GithubPrData, 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;
+	const base = json.base as Record<string, unknown> | undefined;
+	const head = json.head as Record<string, unknown> | undefined;
+
+	return {
+		number: json.number as number,
+		title: json.title as string,
+		url: json.html_url as string,
+		base_branch: (base?.ref as string) ?? "unknown",
+		head_branch: (head?.ref as string) ?? "unknown",
+		author: (user?.login as string) ?? "unknown",
+		author_avatar: (user?.avatar_url as string) ?? undefined,
+		author_url: (user?.html_url as string) ?? undefined,
+		additions: (json.additions as number) ?? 0,
+		deletions: (json.deletions as number) ?? 0,
+		changed_files: (json.changed_files as number) ?? 0,
+	};
+}
+
+interface GithubCommitResponse {
+	sha: string;
+	commit: {
+		message: string;
+		author: { name: string; date: string };
+	};
+	files?: Array<{ filename: string }>;
+}
+
+export function mapCommitsResponse(items: GithubCommitResponse[]): PrCommit[] {
+	return items.map((item) => ({
+		sha: item.sha.slice(0, 8),
+		message: item.commit.message,
+		author: item.commit.author.name,
+		date: item.commit.author.date,
+		files: item.files?.map((f) => f.filename) ?? [],
+	}));
+}
+
+async function githubGet(url: string, token: string): Promise<Response> {
+	const response = await fetch(url, {
+		headers: {
+			Authorization: `token ${token}`,
+			Accept: "application/vnd.github.v3+json",
+			"User-Agent": "newpr-cli",
+		},
+	});
+
+	if (response.status === 404) {
+		throw new Error(`Not found: ${url}`);
+	}
+	if (response.status === 401 || response.status === 403) {
+		throw new Error("GitHub authentication failed. Check your token permissions.");
+	}
+	if (!response.ok) {
+		throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+	}
+
+	return response;
+}
+
+export async function fetchPrCommits(pr: PrIdentifier, token: string): Promise<PrCommit[]> {
+	const allCommits: GithubCommitResponse[] = [];
+	let page = 1;
+
+	while (true) {
+		const url = `https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}/commits?per_page=100&page=${page}`;
+		const response = await githubGet(url, token);
+		const items = (await response.json()) as GithubCommitResponse[];
+		if (items.length === 0) break;
+		allCommits.push(...items);
+		if (items.length < 100) break;
+		page++;
+	}
+
+	return mapCommitsResponse(allCommits);
+}
+
+export async function fetchPrData(pr: PrIdentifier, token: string): Promise<GithubPrData> {
+	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>;
+	const base = mapPrResponse(json);
+
+	const commits = await fetchPrCommits(pr, token);
+
+	return { ...base, commits };
+}

package/src/github/parse-pr.ts

@@ -0,0 +1,39 @@
+import type { PrIdentifier } from "../types/github.ts";
+
+const GITHUB_URL_RE = /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/;
+const OWNER_REPO_NUM_RE = /^([^/]+)\/([^#]+)#(\d+)$/;
+
+export function parsePrInput(input: string, repoFlag?: string): PrIdentifier {
+	const urlMatch = input.match(GITHUB_URL_RE);
+	if (urlMatch) {
+		return { owner: urlMatch[1]!, repo: urlMatch[2]!, number: Number(urlMatch[3]) };
+	}
+
+	const ownerRepoMatch = input.match(OWNER_REPO_NUM_RE);
+	if (ownerRepoMatch) {
+		return {
+			owner: ownerRepoMatch[1]!,
+			repo: ownerRepoMatch[2]!,
+			number: Number(ownerRepoMatch[3]),
+		};
+	}
+
+	const numberOnly = input.replace(/^#/, "");
+	const prNumber = Number(numberOnly);
+	if (!Number.isNaN(prNumber) && prNumber > 0 && Number.isInteger(prNumber)) {
+		if (!repoFlag) {
+			throw new Error(
+				`PR number "${input}" requires --repo flag (e.g., --repo owner/repo)`,
+			);
+		}
+		const parts = repoFlag.split("/");
+		if (parts.length !== 2 || !parts[0] || !parts[1]) {
+			throw new Error(`Invalid --repo format: "${repoFlag}". Expected "owner/repo".`);
+		}
+		return { owner: parts[0], repo: parts[1], number: prNumber };
+	}
+
+	throw new Error(
+		`Cannot parse PR input: "${input}". Expected: URL, owner/repo#123, #123, or 123 with --repo`,
+	);
+}

package/src/history/store.ts

@@ -0,0 +1,96 @@
+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 { SessionRecord } from "./types.ts";
+
+const HISTORY_DIR = join(homedir(), ".newpr", "history");
+const INDEX_FILE = join(HISTORY_DIR, "index.json");
+const SESSIONS_DIR = join(HISTORY_DIR, "sessions");
+
+function ensureDirs(): void {
+	mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+
+export function generateSessionId(): string {
+	return randomBytes(8).toString("hex");
+}
+
+export function buildSessionRecord(id: string, data: NewprOutput): SessionRecord {
+	const { meta, summary } = data;
+	const repoParts = meta.pr_url.match(/github\.com\/([^/]+\/[^/]+)/);
+	return {
+		id,
+		pr_url: meta.pr_url,
+		pr_number: meta.pr_number,
+		pr_title: meta.pr_title,
+		repo: repoParts?.[1] ?? "unknown",
+		author: meta.author,
+		analyzed_at: meta.analyzed_at,
+		risk_level: summary.risk_level,
+		total_files: meta.total_files_changed,
+		total_additions: meta.total_additions,
+		total_deletions: meta.total_deletions,
+		summary_purpose: summary.purpose,
+		data_path: `sessions/${id}.json`,
+	};
+}
+
+async function readIndex(): Promise<SessionRecord[]> {
+	try {
+		const file = Bun.file(INDEX_FILE);
+		if (!(await file.exists())) return [];
+		return JSON.parse(await file.text()) as SessionRecord[];
+	} catch {
+		return [];
+	}
+}
+
+async function writeIndex(records: SessionRecord[]): Promise<void> {
+	ensureDirs();
+	await Bun.write(INDEX_FILE, `${JSON.stringify(records, null, 2)}\n`);
+}
+
+export async function saveSession(data: NewprOutput): Promise<SessionRecord> {
+	const id = generateSessionId();
+	const record = buildSessionRecord(id, data);
+
+	ensureDirs();
+	await Bun.write(join(SESSIONS_DIR, `${id}.json`), JSON.stringify(data, null, 2));
+
+	const index = await readIndex();
+	const deduped = index.filter(
+		(r) => !(r.pr_url === record.pr_url && r.pr_number === record.pr_number),
+	);
+	const updated = [record, ...deduped];
+	await writeIndex(updated);
+
+	return record;
+}
+
+export async function listSessions(limit = 20): Promise<SessionRecord[]> {
+	const index = await readIndex();
+	return index.slice(0, limit);
+}
+
+export async function loadSession(id: string): Promise<NewprOutput | null> {
+	try {
+		const filePath = join(SESSIONS_DIR, `${id}.json`);
+		const file = Bun.file(filePath);
+		if (!(await file.exists())) return null;
+		return JSON.parse(await file.text()) as NewprOutput;
+	} catch {
+		return null;
+	}
+}
+
+export async function clearHistory(): Promise<void> {
+	if (existsSync(HISTORY_DIR)) {
+		rmSync(HISTORY_DIR, { recursive: true });
+	}
+}
+
+export function getHistoryPath(): string {
+	return HISTORY_DIR;
+}

package/src/history/types.ts

@@ -0,0 +1,15 @@
+export interface SessionRecord {
+	id: string;
+	pr_url: string;
+	pr_number: number;
+	pr_title: string;
+	repo: string;
+	author: string;
+	analyzed_at: string;
+	risk_level: string;
+	total_files: number;
+	total_additions: number;
+	total_deletions: number;
+	summary_purpose: string;
+	data_path: string;
+}

package/src/llm/claude-code-client.ts

@@ -0,0 +1,134 @@
+import type { LlmClient, LlmResponse, StreamChunkCallback } from "./client.ts";
+
+async function findClaude(): Promise<string | null> {
+	try {
+		const result = await Bun.$`which claude`.text();
+		return result.trim() || null;
+	} catch {
+		return null;
+	}
+}
+
+let claudePath: string | null | undefined;
+
+async function getClaude(): Promise<string> {
+	if (claudePath === undefined) {
+		claudePath = await findClaude();
+	}
+	if (!claudePath) {
+		throw new Error(
+			"Claude Code is not installed.\n\n" +
+			"To use newpr without an OpenRouter API key, install Claude Code:\n" +
+			"  npm install -g @anthropic-ai/claude-code\n\n" +
+			"Or set OPENROUTER_API_KEY in your environment.",
+		);
+	}
+	return claudePath;
+}
+
+function buildPrompt(systemPrompt: string, userPrompt: string): string {
+	return `<system>\n${systemPrompt}\n</system>\n\n${userPrompt}`;
+}
+
+export function createClaudeCodeClient(timeout: number): LlmClient {
+	return {
+		async complete(systemPrompt: string, userPrompt: string): Promise<LlmResponse> {
+			const bin = await getClaude();
+			const prompt = buildPrompt(systemPrompt, userPrompt);
+
+			const proc = Bun.spawn(
+				[bin, "-p", "--output-format", "text", prompt],
+				{ cwd: process.cwd(), stdin: "ignore", stdout: "pipe", stderr: "ignore" },
+			);
+
+			const timeoutId = setTimeout(() => proc.kill(), timeout * 1000);
+			const content = await new Response(proc.stdout).text();
+			clearTimeout(timeoutId);
+
+			const exitCode = await proc.exited;
+			if (exitCode !== 0 || !content.trim()) {
+				throw new Error(`Claude Code exited with code ${exitCode}`);
+			}
+
+			return {
+				content: content.trim(),
+				model: "claude-code",
+				usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+			};
+		},
+
+		async completeStream(
+			systemPrompt: string,
+			userPrompt: string,
+			onChunk: StreamChunkCallback,
+		): Promise<LlmResponse> {
+			const bin = await getClaude();
+			const prompt = buildPrompt(systemPrompt, userPrompt);
+
+			const proc = Bun.spawn(
+				[bin, "-p", "--output-format", "stream-json", prompt],
+				{ cwd: process.cwd(), stdin: "ignore", stdout: "pipe", stderr: "ignore" },
+			);
+
+			let accumulated = "";
+			let resultText = "";
+			const reader = proc.stdout!.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+
+			const timeoutId = setTimeout(() => proc.kill(), timeout * 1000);
+
+			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 raw of lines) {
+						const line = raw.trim();
+						if (!line) continue;
+						try {
+							const event = JSON.parse(line);
+							if (event.type === "assistant" && event.message?.content) {
+								for (const block of event.message.content) {
+									if (block.type === "text" && block.text) {
+										accumulated += block.text;
+										onChunk(block.text, accumulated);
+									}
+								}
+							} else if (event.type === "result") {
+								resultText = event.result ?? accumulated;
+							} else if (event.type === "content_block_delta") {
+								const delta = event.delta?.text ?? "";
+								if (delta) {
+									accumulated += delta;
+									onChunk(delta, accumulated);
+								}
+							}
+						} catch {}
+					}
+				}
+			} finally {
+				reader.releaseLock();
+				clearTimeout(timeoutId);
+			}
+
+			const content = resultText || accumulated;
+			if (!content.trim()) {
+				throw new Error("Claude Code returned empty response");
+			}
+
+			return {
+				content: content.trim(),
+				model: "claude-code",
+				usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+			};
+		},
+	};
+}
+
+export async function isClaudeCodeAvailable(): Promise<boolean> {
+	return (await findClaude()) !== null;
+}