newpr 0.1.0

package/src/cli/args.ts

@@ -0,0 +1,192 @@
+import type { AgentToolName } from "../workspace/types.ts";
+
+export interface CliArgs {
+	command: "shell" | "review" | "auth" | "history" | "web" | "help" | "version";
+	prInput?: string;
+	repo?: string;
+	model?: string;
+	output: "tui" | "json" | "stream-json" | "pretty";
+	verbose: boolean;
+	noClone: boolean;
+	agent?: AgentToolName;
+	port?: number;
+	subArgs: string[];
+}
+
+function printHelp(): void {
+	const help = `
+newpr - AI-powered large PR review tool
+
+Usage:
+  newpr                                # launch interactive shell
+  newpr <pr-url>                       # launch shell with PR pre-loaded
+  newpr --web [--port 3000]            # launch web UI
+  newpr review <pr-url> --json         # non-interactive JSON output
+  newpr history                        # list past review sessions
+  newpr history show <id>              # show full JSON for a session
+  newpr history clear                  # clear all history
+  newpr auth [--key <api-key>]
+  newpr auth status
+  newpr auth logout
+  newpr help
+  newpr version
+
+Examples:
+  newpr                                            # interactive shell
+  newpr https://github.com/owner/repo/pull/123     # shell + auto-analyze
+  newpr --web --port 8080                          # web UI on port 8080
+  newpr review owner/repo#123 --json               # pipe-friendly JSON
+  newpr review 123 --repo owner/repo --no-clone    # diff-only (no git clone)
+  newpr auth --key sk-or-xxx
+
+Options:
+  --web                 Launch web UI instead of TUI
+  --port <number>       Port for web server (default: 3000)
+
+Options (review mode):
+  --repo <owner/repo>   Repository (required when using PR number only)
+  --model <model>       Override LLM model (default: anthropic/claude-sonnet-4.5)
+  --agent <tool>        Preferred agent: claude | opencode | codex (default: auto)
+  --no-clone            Skip git clone, diff-only analysis (faster, less context)
+  --json                Output raw JSON (for piping/scripting)
+  --stream-json         Stream progress as NDJSON, then emit result
+  --output <format>     Output format: tui (default) | json | stream-json | pretty
+  --verbose             Show progress on stderr (non-TUI modes)
+  -h, --help            Show this help
+  -v, --version         Show version
+
+Environment Variables:
+  OPENROUTER_API_KEY    Required. Your OpenRouter API key.
+  GITHUB_TOKEN          Optional. Falls back to gh CLI token.
+  NEWPR_MODEL           Default model override.
+  NEWPR_MAX_FILES       Max files to analyze (default: 100).
+  NEWPR_TIMEOUT         Timeout per LLM call in seconds (default: 120).
+  NEWPR_CONCURRENCY     Parallel LLM calls (default: 5).
+`.trim();
+
+	console.log(help);
+}
+
+const DEFAULTS = { output: "tui" as const, verbose: false, noClone: false, subArgs: [] as string[] };
+
+function looksLikePrInput(s: string): boolean {
+	return (
+		s.startsWith("http://") ||
+		s.startsWith("https://") ||
+		s.includes("#") ||
+		/^\d+$/.test(s) ||
+		/^[^/]+\/[^/]+#\d+$/.test(s)
+	);
+}
+
+function parseAgentName(val: string | undefined): AgentToolName | undefined {
+	if (val === "claude" || val === "opencode" || val === "codex") return val;
+	return undefined;
+}
+
+export function parseArgs(argv: string[]): CliArgs {
+	const args = argv.slice(2);
+
+	if (args.includes("-h") || args.includes("--help")) {
+		printHelp();
+		return { command: "help", ...DEFAULTS };
+	}
+
+	if (args.includes("-v") || args.includes("--version")) {
+		return { command: "version", ...DEFAULTS };
+	}
+
+	if (args.includes("--web")) {
+		let port = 3000;
+		const portIdx = args.indexOf("--port");
+		if (portIdx !== -1 && args[portIdx + 1]) {
+			port = Number.parseInt(args[portIdx + 1]!, 10) || 3000;
+		}
+		return { command: "web", port, ...DEFAULTS };
+	}
+
+	if (args.length === 0) {
+		return { command: "shell", ...DEFAULTS };
+	}
+
+	const command = args[0]!;
+
+	if (command === "version") {
+		return { command: "version", ...DEFAULTS };
+	}
+	if (command === "help") {
+		printHelp();
+		return { command: "help", ...DEFAULTS };
+	}
+	if (command === "auth") {
+		return { command: "auth", ...DEFAULTS, subArgs: args.slice(1) };
+	}
+	if (command === "history") {
+		return { command: "history", ...DEFAULTS, subArgs: args.slice(1) };
+	}
+
+	if (command === "review") {
+		return parseReviewArgs(args.slice(1));
+	}
+
+	if (looksLikePrInput(command)) {
+		return { command: "shell", prInput: command, ...DEFAULTS };
+	}
+
+	console.error(`Unknown command: ${command}\n`);
+	printHelp();
+	return { command: "help", ...DEFAULTS };
+}
+
+function parseReviewArgs(args: string[]): CliArgs {
+	const prInput = args[0];
+	if (!prInput || prInput.startsWith("-")) {
+		console.error("Error: PR URL or number is required.\n");
+		printHelp();
+		process.exit(1);
+	}
+
+	let repo: string | undefined;
+	let model: string | undefined;
+	let agent: AgentToolName | undefined;
+	let output: "tui" | "json" | "stream-json" | "pretty" = "tui";
+	let verbose = false;
+	let noClone = false;
+
+	for (let i = 1; i < args.length; i++) {
+		const arg = args[i];
+		switch (arg) {
+			case "--repo":
+				repo = args[++i];
+				break;
+			case "--model":
+				model = args[++i];
+				break;
+			case "--agent":
+				agent = parseAgentName(args[++i]);
+				break;
+			case "--no-clone":
+				noClone = true;
+				break;
+			case "--json":
+				output = "json";
+				break;
+			case "--stream-json":
+				output = "stream-json";
+				break;
+			case "--output": {
+				const val = args[++i];
+				if (val === "json") output = "json";
+				else if (val === "stream-json") output = "stream-json";
+				else if (val === "pretty") output = "pretty";
+				else output = "tui";
+				break;
+			}
+			case "--verbose":
+				verbose = true;
+				break;
+		}
+	}
+
+	return { command: "review", prInput, repo, model, agent, output, verbose, noClone, subArgs: [] };
+}

package/src/cli/auth.ts

@@ -0,0 +1,82 @@
+import { readStoredConfig, writeStoredConfig, getConfigPath, deleteStoredKey } from "../config/store.ts";
+
+async function promptForKey(): Promise<string> {
+	process.stdout.write("Enter your OpenRouter API key: ");
+	const reader = Bun.stdin.stream().getReader();
+	const { value } = await reader.read();
+	reader.releaseLock();
+	const input = value ? new TextDecoder().decode(value).trim() : "";
+	if (!input) {
+		throw new Error("No API key provided.");
+	}
+	return input;
+}
+
+function maskKey(key: string): string {
+	if (key.length <= 8) return "****";
+	return `${key.slice(0, 6)}...${key.slice(-4)}`;
+}
+
+export async function handleAuth(subArgs: string[]): Promise<void> {
+	const subcommand = subArgs[0];
+
+	if (subcommand === "status") {
+		return showStatus();
+	}
+
+	if (subcommand === "logout") {
+		await deleteStoredKey("openrouter_api_key");
+		console.log("OpenRouter API key removed from config.");
+		return;
+	}
+
+	const keyFlagIdx = subArgs.indexOf("--key");
+	let key: string;
+
+	if (keyFlagIdx !== -1) {
+		const keyValue = subArgs[keyFlagIdx + 1];
+		if (!keyValue) {
+			console.error("Error: --key requires a value. Usage: newpr auth --key sk-or-...");
+			process.exit(1);
+		}
+		key = keyValue;
+	} else {
+		key = await promptForKey();
+	}
+
+	if (!key.startsWith("sk-or-")) {
+		console.error("Warning: Key doesn't start with 'sk-or-'. Are you sure this is an OpenRouter key?");
+	}
+
+	await writeStoredConfig({ openrouter_api_key: key });
+	console.log(`API key saved to ${getConfigPath()}`);
+	console.log(`Key: ${maskKey(key)}`);
+}
+
+async function showStatus(): Promise<void> {
+	const envKey = process.env.OPENROUTER_API_KEY;
+	const stored = await readStoredConfig();
+
+	console.log("Authentication Status:");
+	console.log("─".repeat(40));
+
+	if (envKey) {
+		console.log(`  env OPENROUTER_API_KEY: ${maskKey(envKey)} (active)`);
+	} else {
+		console.log("  env OPENROUTER_API_KEY: not set");
+	}
+
+	if (stored.openrouter_api_key) {
+		const isActive = !envKey;
+		console.log(`  config file:           ${maskKey(stored.openrouter_api_key)}${isActive ? " (active)" : " (overridden by env)"}`);
+	} else {
+		console.log("  config file:           not set");
+	}
+
+	console.log("");
+	console.log(`Config path: ${getConfigPath()}`);
+
+	if (!envKey && !stored.openrouter_api_key) {
+		console.log("\nNo API key configured. Run `newpr auth` to set one.");
+	}
+}

package/src/cli/history-cmd.ts

@@ -0,0 +1,64 @@
+import { listSessions, loadSession, clearHistory, getHistoryPath } from "../history/store.ts";
+
+const RISK_COLORS: Record<string, string> = {
+	low: "\x1b[32m",
+	medium: "\x1b[33m",
+	high: "\x1b[31m",
+};
+const RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+
+export async function handleHistory(subArgs: string[]): Promise<void> {
+	const sub = subArgs[0];
+
+	if (sub === "clear") {
+		await clearHistory();
+		console.log("History cleared.");
+		return;
+	}
+
+	if (sub === "show") {
+		const id = subArgs[1];
+		if (!id) {
+			console.error("Usage: newpr history show <session-id>");
+			process.exit(1);
+		}
+		const data = await loadSession(id);
+		if (!data) {
+			console.error(`Session ${id} not found.`);
+			process.exit(1);
+		}
+		console.log(JSON.stringify(data, null, 2));
+		return;
+	}
+
+	if (sub === "path") {
+		console.log(getHistoryPath());
+		return;
+	}
+
+	const limit = sub ? Number.parseInt(sub, 10) : 20;
+	const sessions = await listSessions(Number.isNaN(limit) ? 20 : limit);
+
+	if (sessions.length === 0) {
+		console.log("No review history yet. Run `newpr` to analyze a PR.");
+		return;
+	}
+
+	console.log(`${BOLD}${CYAN}Review History${RESET} ${DIM}(${sessions.length} sessions)${RESET}\n`);
+
+	for (const s of sessions) {
+		const riskColor = RISK_COLORS[s.risk_level] ?? RISK_COLORS.medium;
+		const date = new Date(s.analyzed_at).toLocaleDateString();
+		console.log(
+			`  ${BOLD}#${s.pr_number}${RESET} ${s.pr_title}`,
+		);
+		console.log(
+			`  ${DIM}${s.repo} │ ${s.author} │ ${date} │ ${riskColor}${s.risk_level}${RESET}${DIM} │ ${s.total_files} files │ +${s.total_additions} -${s.total_deletions}${RESET}`,
+		);
+		console.log(`  ${DIM}${s.summary_purpose}${RESET}`);
+		console.log(`  ${DIM}id: ${s.id}${RESET}\n`);
+	}
+}

package/src/cli/index.ts

@@ -0,0 +1,115 @@
+#!/usr/bin/env bun
+import { parseArgs } from "./args.ts";
+import { handleAuth } from "./auth.ts";
+import { handleHistory } from "./history-cmd.ts";
+import { formatPretty } from "./pretty.ts";
+import { loadConfig } from "../config/index.ts";
+import { getGithubToken } from "../github/auth.ts";
+import { parsePrInput } from "../github/parse-pr.ts";
+import { analyzePr } from "../analyzer/pipeline.ts";
+import { createStderrProgress, createSilentProgress, createStreamJsonProgress } from "../analyzer/progress.ts";
+import { renderLoading, renderShell } from "../tui/render.tsx";
+
+const VERSION = "0.1.0";
+
+async function main(): Promise<void> {
+	const args = parseArgs(process.argv);
+
+	if (args.command === "help") return;
+
+	if (args.command === "version") {
+		console.log(`newpr v${VERSION}`);
+		return;
+	}
+
+	if (args.command === "auth") {
+		try {
+			await handleAuth(args.subArgs);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			process.stderr.write(`Error: ${message}\n`);
+			process.exit(1);
+		}
+		return;
+	}
+
+	if (args.command === "history") {
+		try {
+			await handleHistory(args.subArgs);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			process.stderr.write(`Error: ${message}\n`);
+			process.exit(1);
+		}
+		return;
+	}
+
+	if (args.command === "web") {
+		try {
+			const config = await loadConfig({ model: args.model });
+			const token = await getGithubToken();
+			const { startWebServer } = await import("../web/server.ts");
+			await startWebServer({ port: args.port ?? 3000, token, config });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			process.stderr.write(`Error: ${message}\n`);
+			process.exit(1);
+		}
+		return;
+	}
+
+	if (args.command === "shell") {
+		try {
+			const config = await loadConfig({ model: args.model });
+			const token = await getGithubToken();
+			renderShell(token, config, args.prInput);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			process.stderr.write(`Error: ${message}\n`);
+			process.exit(1);
+		}
+		return;
+	}
+
+	try {
+		const config = await loadConfig({ model: args.model });
+		const token = await getGithubToken();
+		const pr = parsePrInput(args.prInput!, args.repo);
+		const pipelineOpts = {
+			pr,
+			token,
+			config,
+			noClone: args.noClone,
+			preferredAgent: args.agent ?? config.agent,
+		};
+
+		if (args.output === "tui") {
+			const loading = await renderLoading();
+			const result = await analyzePr({
+				...pipelineOpts,
+				onProgress: (event) => loading.update(event),
+			});
+			loading.finish(result);
+		} else if (args.output === "stream-json") {
+			const progress = createStreamJsonProgress();
+			const result = await analyzePr({ ...pipelineOpts, onProgress: progress });
+			const resultLine = JSON.stringify({ type: "result", data: result });
+			process.stdout.write(`${resultLine}\n`);
+		} else {
+			const progress = args.verbose ? createStderrProgress() : createSilentProgress();
+			const result = await analyzePr({ ...pipelineOpts, onProgress: progress });
+
+			if (args.output === "pretty") {
+				console.log(formatPretty(result));
+			} else {
+				console.log(JSON.stringify(result, null, 2));
+			}
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`Error: ${message}\n`);
+		process.exit(1);
+	}
+}
+
+main();

package/src/cli/pretty.ts

@@ -0,0 +1,79 @@
+import type { NewprOutput } from "../types/output.ts";
+
+const COLORS = {
+	reset: "\x1b[0m",
+	bold: "\x1b[1m",
+	dim: "\x1b[2m",
+	red: "\x1b[31m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+	blue: "\x1b[34m",
+	magenta: "\x1b[35m",
+	cyan: "\x1b[36m",
+};
+
+const RISK_COLORS: Record<string, string> = {
+	low: COLORS.green,
+	medium: COLORS.yellow,
+	high: COLORS.red,
+};
+
+const GROUP_TYPE_ICONS: Record<string, string> = {
+	feature: "+",
+	refactor: "~",
+	bugfix: "!",
+	chore: "*",
+	docs: "#",
+	test: "T",
+	config: "C",
+};
+
+function line(char = "─", length = 60): string {
+	return char.repeat(length);
+}
+
+export function formatPretty(output: NewprOutput): string {
+	const lines: string[] = [];
+
+	lines.push("");
+	lines.push(`${COLORS.bold}${COLORS.cyan}${line("═")}${COLORS.reset}`);
+	lines.push(`${COLORS.bold}  PR #${output.meta.pr_number}: ${output.meta.pr_title}${COLORS.reset}`);
+	lines.push(`${COLORS.dim}  ${output.meta.author} | ${output.meta.base_branch} <- ${output.meta.head_branch}${COLORS.reset}`);
+	lines.push(`${COLORS.dim}  ${output.meta.total_files_changed} files | +${output.meta.total_additions} -${output.meta.total_deletions}${COLORS.reset}`);
+	lines.push(`${COLORS.bold}${COLORS.cyan}${line("═")}${COLORS.reset}`);
+
+	lines.push("");
+	lines.push(`${COLORS.bold}SUMMARY${COLORS.reset}`);
+	lines.push(`${line("─")}`);
+	lines.push(`  Purpose: ${output.summary.purpose}`);
+	lines.push(`  Scope:   ${output.summary.scope}`);
+	lines.push(`  Impact:  ${output.summary.impact}`);
+	const riskColor = RISK_COLORS[output.summary.risk_level] ?? COLORS.yellow;
+	lines.push(`  Risk:    ${riskColor}${output.summary.risk_level.toUpperCase()}${COLORS.reset}`);
+
+	lines.push("");
+	lines.push(`${COLORS.bold}CHANGE GROUPS${COLORS.reset}`);
+	lines.push(`${line("─")}`);
+	for (const group of output.groups) {
+		const icon = GROUP_TYPE_ICONS[group.type] ?? "*";
+		lines.push(`  ${COLORS.bold}[${icon}] ${group.name}${COLORS.reset} ${COLORS.dim}(${group.type}, ${group.files.length} files)${COLORS.reset}`);
+		lines.push(`      ${group.description}`);
+	}
+
+	lines.push("");
+	lines.push(`${COLORS.bold}FILES${COLORS.reset}`);
+	lines.push(`${line("─")}`);
+	for (const file of output.files) {
+		const statusIcon = file.status === "added" ? `${COLORS.green}A` : file.status === "deleted" ? `${COLORS.red}D` : file.status === "renamed" ? `${COLORS.blue}R` : `${COLORS.yellow}M`;
+		lines.push(`  ${statusIcon}${COLORS.reset} ${file.path} ${COLORS.dim}(+${file.additions}/-${file.deletions})${COLORS.reset}`);
+		lines.push(`    ${COLORS.dim}${file.summary}${COLORS.reset}`);
+	}
+
+	lines.push("");
+	lines.push(`${COLORS.bold}NARRATIVE${COLORS.reset}`);
+	lines.push(`${line("─")}`);
+	lines.push(output.narrative);
+	lines.push("");
+
+	return lines.join("\n");
+}

package/src/config/index.ts

@@ -0,0 +1,103 @@
+import { DEFAULT_CONFIG, type NewprConfig } from "../types/config.ts";
+import { readStoredConfig, type StoredConfig } from "./store.ts";
+
+export interface ConfigOverrides {
+	model?: string;
+	max_files?: number;
+	timeout?: number;
+	concurrency?: number;
+	language?: string;
+}
+
+function parseIntOrDefault(value: string | undefined, fallback: number): number {
+	if (!value) return fallback;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isNaN(parsed) ? fallback : parsed;
+}
+
+const LOCALE_TO_LANGUAGE: Record<string, string> = {
+	ko: "Korean",
+	ja: "Japanese",
+	zh: "Chinese",
+	es: "Spanish",
+	fr: "French",
+	de: "German",
+	pt: "Portuguese",
+	ru: "Russian",
+	it: "Italian",
+	vi: "Vietnamese",
+	th: "Thai",
+	ar: "Arabic",
+	hi: "Hindi",
+	nl: "Dutch",
+	pl: "Polish",
+	tr: "Turkish",
+	sv: "Swedish",
+	en: "English",
+};
+
+export function detectLanguage(): string {
+	const envLang = process.env.LANG || process.env.LC_ALL || process.env.LC_MESSAGES || "";
+	const code = envLang.split(/[_.\-]/)[0]?.toLowerCase() ?? "";
+	if (code && LOCALE_TO_LANGUAGE[code]) return LOCALE_TO_LANGUAGE[code]!;
+
+	try {
+		const resolved = Intl.DateTimeFormat().resolvedOptions().locale;
+		const intlCode = resolved.split("-")[0]?.toLowerCase() ?? "";
+		if (intlCode && LOCALE_TO_LANGUAGE[intlCode]) return LOCALE_TO_LANGUAGE[intlCode]!;
+	} catch {}
+
+	return "English";
+}
+
+export function resolveLanguage(configured: string): string {
+	if (configured === "auto") return detectLanguage();
+	return configured;
+}
+
+export async function loadConfig(
+	overrides?: ConfigOverrides,
+	_readStore?: () => Promise<StoredConfig>,
+): Promise<NewprConfig> {
+	const stored = await (_readStore ?? readStoredConfig)();
+
+	const apiKey = process.env.OPENROUTER_API_KEY || stored.openrouter_api_key;
+	if (!apiKey) {
+		throw new Error(
+			"OPENROUTER_API_KEY is not set. Run `newpr auth` to configure, or set the environment variable.",
+		);
+	}
+
+	const agentVal = stored.agent as NewprConfig["agent"];
+	const rawLang = process.env.NEWPR_LANGUAGE || stored.language || DEFAULT_CONFIG.language;
+
+	const config: NewprConfig = {
+		openrouter_api_key: apiKey,
+		agent: agentVal === "claude" || agentVal === "opencode" || agentVal === "codex" ? agentVal : undefined,
+		model:
+			process.env.NEWPR_MODEL || stored.model || DEFAULT_CONFIG.model,
+		max_files: parseIntOrDefault(
+			process.env.NEWPR_MAX_FILES,
+			stored.max_files ?? DEFAULT_CONFIG.max_files,
+		),
+		timeout: parseIntOrDefault(
+			process.env.NEWPR_TIMEOUT,
+			stored.timeout ?? DEFAULT_CONFIG.timeout,
+		),
+		concurrency: parseIntOrDefault(
+			process.env.NEWPR_CONCURRENCY,
+			stored.concurrency ?? DEFAULT_CONFIG.concurrency,
+		),
+		language: resolveLanguage(rawLang),
+	};
+
+	if (overrides) {
+		if (overrides.model) config.model = overrides.model;
+		if (overrides.max_files !== undefined) config.max_files = overrides.max_files;
+		if (overrides.timeout !== undefined) config.timeout = overrides.timeout;
+		if (overrides.concurrency !== undefined) config.concurrency = overrides.concurrency;
+		if (overrides.language) config.language = resolveLanguage(overrides.language);
+	}
+
+	return config;
+}

package/src/config/store.ts

@@ -0,0 +1,50 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+
+const CONFIG_DIR = join(homedir(), ".newpr");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export interface StoredConfig {
+	openrouter_api_key?: string;
+	model?: string;
+	max_files?: number;
+	timeout?: number;
+	concurrency?: number;
+	language?: string;
+	agent?: string;
+}
+
+function ensureDir(): void {
+	mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+export function getConfigPath(): string {
+	return CONFIG_FILE;
+}
+
+export async function readStoredConfig(): Promise<StoredConfig> {
+	try {
+		const file = Bun.file(CONFIG_FILE);
+		const exists = await file.exists();
+		if (!exists) return {};
+		const text = await file.text();
+		return JSON.parse(text) as StoredConfig;
+	} catch {
+		return {};
+	}
+}
+
+export async function writeStoredConfig(update: StoredConfig): Promise<void> {
+	ensureDir();
+	const existing = await readStoredConfig();
+	const merged = { ...existing, ...update };
+	await Bun.write(CONFIG_FILE, `${JSON.stringify(merged, null, 2)}\n`);
+}
+
+export async function deleteStoredKey(key: keyof StoredConfig): Promise<void> {
+	const existing = await readStoredConfig();
+	delete existing[key];
+	ensureDir();
+	await Bun.write(CONFIG_FILE, `${JSON.stringify(existing, null, 2)}\n`);
+}