newpr 0.2.0 → 0.4.0

package/README.md

@@ -1,78 +1,86 @@
 # newpr
 
-AI-powered PR review tool for understanding large pull requests with 1000+ lines of changes.
+AI-powered PR review tool that turns large pull requests into readable, navigable stories.
 
-newpr fetches a GitHub PR, optionally clones the repo for deep codebase exploration using an agentic coding tool, then uses an LLM to produce a structured analysis: file summaries, logical groupings, an overall summary, and a narrative walkthrough with clickable cross-references.
+## Quick Install
 
-## Features
-
-- **Narrative walkthrough** — reads like an article, with `[[group:...]]` and `[[file:...]]` cross-references
-- **Logical grouping** — clusters changed files by purpose (feature, refactor, bugfix, etc.)
-- **Codebase exploration** — uses Claude Code / OpenCode / Codex to analyze the actual repository, not just the diff
-- **Interactive TUI** — Ink-based terminal UI with tabbed panels, slash commands, ASCII logo
-- **Web UI** — browser-based interface with sidebar, resizable panels, markdown rendering, dark/light mode
-- **Streaming progress** — real-time SSE streaming of analysis steps
-- **Session history** — saves past analyses for instant recall
-- **Multi-language** — output in any language (auto-detected or configured)
+```bash
+bunx newpr --web
+```
 
-## Quick Start
+Or install globally:
 
 ```bash
-bun install
+bun add -g newpr
+newpr --web
 ```
 
-### Option A: OpenRouter API key
+The web UI opens automatically at `http://localhost:3000`. Paste any GitHub PR URL to start.
+
+### Prerequisites
+
+- [Bun](https://bun.sh) — `curl -fsSL https://bun.sh/install | bash`
+- [GitHub CLI](https://cli.github.com) — `brew install gh && gh auth login`
+- One of:
+  - `OPENROUTER_API_KEY` — for model selection (Claude, GPT-4, Gemini, etc.)
+  - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) — zero-config fallback
 
 ```bash
+# Option A: OpenRouter
 export OPENROUTER_API_KEY=sk-or-...
-newpr https://github.com/owner/repo/pull/123
+newpr --web
+
+# Option B: Claude Code (no API key needed)
+newpr --web
 ```
 
-### Option B: Claude Code (no API key needed)
+## What it Does
 
-If you have [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed, newpr uses it as a fallback when no OpenRouter API key is set — for both LLM analysis and codebase exploration.
+newpr fetches a GitHub PR, clones the repo for deep codebase exploration using an agentic coding tool (Claude Code / OpenCode / Codex), then produces:
 
-```bash
-newpr https://github.com/owner/repo/pull/123
-```
+- **Narrative walkthrough** — prose-first story with clickable code references that open diffs at the exact line
+- **Logical grouping** — clusters files by purpose (feature, refactor, bugfix) with key changes, risk assessment, and dependency mapping
+- **Interactive chat** — ask follow-up questions with agentic tool execution (file diffs, GitHub API, web search)
+- **Inline diff comments** — create/edit/delete review comments synced to GitHub
+- **PR actions** — approve, request changes, or comment directly from the UI
+- **React Doctor** — auto-runs [react-doctor](https://github.com/millionco/react-doctor) on React projects for code quality scoring
 
-### Web UI
+### Anchors & Navigation
 
-```bash
-newpr --web --port 3000
-```
+Every analysis is densely linked. The narrative contains three types of clickable references:
 
-Opens a browser-based UI at `http://localhost:3000` with:
-- Left sidebar with session history
-- Resizable detail panel on the right
-- Clickable group/file anchors in the narrative
-- Settings modal for model, agent, language configuration
-- GitHub profile integration
+| Anchor | Appearance | Action |
+|--------|------------|--------|
+| `[[group:Name]]` | Blue chip | Opens group detail in sidebar |
+| `[[file:path]]` | Blue chip | Opens file diff in sidebar |
+| `[[line:path#L-L]](text)` | Subtle underline | Opens diff scrolled to line, highlights range |
 
 ## Usage
 
-```
-newpr                                # launch interactive shell
-newpr <pr-url>                       # 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 auth [--key <api-key>]         # configure API key
+```bash
+newpr                                 # interactive shell (TUI)
+newpr <pr-url>                        # shell with PR pre-loaded
+newpr --web [--port 3000]             # web UI (default)
+newpr --web --cartoon                 # web UI with comic strip generation
+newpr review <pr-url> --json          # non-interactive JSON output
+newpr history                         # list past sessions
+newpr auth [--key <api-key>]          # configure API key
 ```
 
-### Review mode options
+### Options
 
 ```
---repo <owner/repo>   Repository (when using PR number only)
---model <model>       Override LLM model (default: anthropic/claude-sonnet-4.5)
+--model <model>       LLM model (default: anthropic/claude-sonnet-4.6)
 --agent <tool>        Preferred agent: claude | opencode | codex (default: auto)
---no-clone            Skip git clone, diff-only analysis (faster, less context)
+--port <port>         Web UI port (default: 3000)
+--cartoon             Enable comic strip generation
+--no-clone            Skip git clone, diff-only analysis
 --json                Output raw JSON
---stream-json         Stream progress as NDJSON, then emit result
+--stream-json         Stream progress as NDJSON
 --verbose             Show progress on stderr
 ```
 
-### PR input formats
+### PR Input Formats
 
 ```bash
 newpr https://github.com/owner/repo/pull/123
@@ -80,66 +88,71 @@ newpr owner/repo#123
 newpr review 123 --repo owner/repo
 ```
 
-## Architecture
+## Web UI
 
-```
-src/
-├── cli/          # CLI entry, arg parsing, auth, history commands
-├── config/       # Config loading (~/.newpr/config.json)
-├── github/       # GitHub API (fetch PR data, diff, parse URL)
-├── diff/         # Unified diff parser + chunker
-├── llm/          # LLM clients (OpenRouter + Claude Code fallback), prompts, response parser
-├── analyzer/     # Pipeline orchestrator + progress events
-├── workspace/    # Agent system (claude/opencode/codex), git operations, codebase exploration
-├── types/        # Shared TypeScript types
-├── history/      # Session persistence (~/.newpr/history/)
-├── tui/          # Ink TUI (shell, panels, theme, slash commands)
-└── web/          # Web UI
-    ├── server.ts           # Bun.serve() with Tailwind CSS build
-    ├── server/             # REST API + SSE endpoints, session manager
-    ├── client/             # React frontend
-    │   ├── components/     # AppShell, ResultsScreen, Markdown, DetailPane, etc.
-    │   ├── panels/         # Story, Summary, Groups, Files, Narrative
-    │   └── hooks/          # useAnalysis, useSessions, useTheme, useGithubUser
-    └── styles/             # Tailwind v4 + Pretendard font
-```
+The web interface provides:
 
-## Analysis Pipeline
+- **Sidebar** — sessions grouped by repository, background analysis tracking
+- **Story tab** — narrative with inline line anchors + chat input at bottom
+- **Discussion tab** — PR description + GitHub comments
+- **Groups tab** — collapsible change groups with key changes and risk
+- **Files tab** — tree/group/changes view modes with inline summaries
+- **Comic tab** — AI-generated 4-panel comic strip (with `--cartoon`)
+- **Right sidebar** — file diffs with syntax highlighting, inline comments, line highlighting
+- **TipTap editor** — `@` to reference files/groups, `/` for commands
+- **KaTeX** — LaTeX math rendering in chat and narrative
+- **Review modal** — approve, request changes, or comment via GitHub API
+- **Settings** — model, agent, language, API keys
+- **Preflight checks** — system health (gh, agents, API key) on startup
 
-1. **Fetch** — PR metadata, commits, and diff from GitHub API
-2. **Parse** — unified diff into per-file chunks
-3. **Clone** — bare repo clone with worktree checkout (cached)
-4. **Explore** — 3-phase codebase exploration via agentic tool (structure → related code → issues)
-5. **Analyze** — LLM summarizes each file chunk in parallel batches
-6. **Group** — LLM clusters files into logical groups with types
-7. **Summarize** — LLM generates purpose, scope, impact, risk level
-8. **Narrate** — LLM writes a walkthrough article with cross-references
+## Chat
 
-## LLM Backend
+The chat in the Story tab supports agentic tool execution:
 
-newpr supports two LLM backends:
+| Tool | Description |
+|------|-------------|
+| `get_file_diff` | Fetch unified diff for a specific file |
+| `list_files` | List all changed files with summaries |
+| `get_pr_comments` | Fetch PR discussion comments |
+| `get_review_comments` | Fetch inline review comments |
+| `get_pr_details` | PR metadata, labels, reviewers |
+| `web_search` | Search the web (delegated to agent) |
+| `web_fetch` | Fetch URL content (delegated to agent) |
+| `run_react_doctor` | Run react-doctor analysis |
 
-| Backend | Setup | Use case |
-|---------|-------|----------|
-| **OpenRouter** | Set `OPENROUTER_API_KEY` | Full model selection (Claude, GPT-4, Gemini, etc.) |
-| **Claude Code** | Install `claude` CLI | Zero-config fallback, uses your existing Claude subscription |
+Type `/undo` to remove the last exchange.
 
-When no OpenRouter API key is configured, newpr automatically falls back to Claude Code for all LLM calls.
+## Analysis Pipeline
 
-## Codebase Exploration Agents
+1. **Fetch** — PR metadata, commits, diff, and discussion from GitHub API
+2. **Parse** — unified diff into per-file chunks
+3. **Clone** — bare repo with worktree checkout (cached in `~/.newpr/repos/`)
+4. **Explore** — 3-4 phase codebase exploration via agent:
+   - Structure — project type, architecture
+   - Related code — imports, usages, tests
+   - Issues — breaking changes, inconsistencies
+   - React Doctor — code quality score (React projects only)
+5. **Analyze** — LLM summarizes each file in parallel batches
+6. **Group** — LLM clusters files with key changes, risk, dependencies
+7. **Summarize** — purpose, scope, impact, risk level
+8. **Narrate** — prose walkthrough with line-level code references
+
+## LLM Backends
+
+| Backend | Setup | Use case |
+|---------|-------|----------|
+| **OpenRouter** | `OPENROUTER_API_KEY` | Full model selection |
+| **Claude Code** | `claude` CLI installed | Zero-config fallback |
 
-For deep analysis beyond the diff, newpr uses an agentic coding tool to explore the actual repository:
+## Exploration Agents
 
-| Agent | Command | Detection |
+| Agent | Install | Detection |
 |-------|---------|-----------|
-| Claude Code | `claude` | `which claude` |
-| OpenCode | `opencode` | `which opencode` |
-| Codex | `codex` | `which codex` |
+| Claude Code | `npm i -g @anthropic-ai/claude-code` | `which claude` |
+| OpenCode | `npm i -g opencode` | `which opencode` |
+| Codex | `npm i -g @openai/codex` | `which codex` |
 
-The agent runs 3 exploration phases:
-1. **Structure** — project type, key directories, architecture pattern
-2. **Related code** — imports, usages, test coverage for changed files
-3. **Issues** — breaking changes, missing error handling, inconsistencies
+Agents run with read-only tools (Read, Glob, Grep, Bash, WebSearch, WebFetch). No write operations.
 
 ## Environment Variables
 
@@ -147,19 +160,19 @@ The agent runs 3 exploration phases:
 |----------|----------|-------------|
 | `OPENROUTER_API_KEY` | No* | OpenRouter API key (*falls back to Claude Code) |
 | `GITHUB_TOKEN` | No | GitHub token (falls back to `gh` CLI) |
-| `NEWPR_MODEL` | No | Default model (default: `anthropic/claude-sonnet-4.5`) |
+| `NEWPR_MODEL` | No | Default model (default: `anthropic/claude-sonnet-4.6`) |
 | `NEWPR_MAX_FILES` | No | Max files to analyze (default: 100) |
 | `NEWPR_TIMEOUT` | No | Timeout per LLM call in seconds (default: 120) |
 | `NEWPR_CONCURRENCY` | No | Parallel LLM calls (default: 5) |
 
-## Config File
+## Config
 
-Persistent settings are stored in `~/.newpr/config.json`:
+Persistent settings in `~/.newpr/config.json`:
 
 ```json
 {
   "openrouter_api_key": "sk-or-...",
-  "model": "anthropic/claude-sonnet-4.5",
+  "model": "anthropic/claude-sonnet-4.6",
   "language": "auto",
   "agent": "claude",
   "max_files": 100,
@@ -171,19 +184,38 @@ Persistent settings are stored in `~/.newpr/config.json`:
 ## Development
 
 ```bash
+git clone https://github.com/jiwonMe/newpr
+cd newpr
 bun install
-bun test              # run tests (91 tests)
+bun test              # 91 tests
 bun run typecheck     # tsc --noEmit
-bun run lint          # biome check
 bun run start         # launch CLI
 ```
 
-## Requirements
+## Architecture
 
-- [Bun](https://bun.sh) ≥ 1.3
-- GitHub CLI (`gh`) for authentication, or `GITHUB_TOKEN`
-- One of: `OPENROUTER_API_KEY` or Claude Code (`claude` CLI)
+```
+src/
+├── cli/          # CLI entry, args, auth, preflight, update-check
+├── config/       # Config loading (~/.newpr/config.json)
+├── github/       # GitHub API (PR data, diff, comments)
+├── diff/         # Unified diff parser + chunker
+├── llm/          # LLM clients (OpenRouter + Claude Code), prompts, parser
+├── analyzer/     # Pipeline orchestrator + progress events
+├── workspace/    # Agent system, git operations, codebase exploration
+├── types/        # Shared TypeScript types
+├── history/      # Session persistence + sidecar files
+├── tui/          # Ink TUI (shell, panels, theme)
+└── web/          # Web UI
+    ├── server.ts           # Bun.serve()
+    ├── server/             # REST/SSE API, session manager
+    ├── client/             # React frontend
+    │   ├── components/     # AppShell, ChatSection, Markdown, TipTapEditor, etc.
+    │   ├── panels/         # Story, Discussion, Groups, Files, Cartoon
+    │   └── hooks/          # useAnalysis, useBackgroundAnalyses, useChatState, etc.
+    └── styles/             # Tailwind v4 + Pretendard + Tab0 Mono K
+```
 
 ## License
 
-Private
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "AI-powered large PR review tool - understand PRs with 1000+ lines of changes",
   "module": "src/cli/index.ts",
   "type": "module",

package/src/analyzer/pipeline.ts

@@ -85,25 +85,21 @@ async function runExploration(
 ): Promise<ExplorationResult> {
 	const agent = await requireAgent(preferredAgent);
 
-	onProgress?.({ stage: "cloning", message: `${pr.owner}/${pr.repo}` });
 	const bareRepoPath = await ensureRepo(pr.owner, pr.repo, token, (msg) => {
-		onProgress?.({ stage: "cloning", message: msg });
+		onProgress?.({ stage: "cloning", message: `📦 ${msg}` });
 	});
-	onProgress?.({ stage: "cloning", message: `${pr.owner}/${pr.repo} ready` });
 
-	onProgress?.({ stage: "checkout", message: `${baseBranch} ← PR #${pr.number}` });
 	const worktrees = await createWorktrees(
 		bareRepoPath, baseBranch, pr.number, pr.owner, pr.repo,
-		(msg) => onProgress?.({ stage: "checkout", message: msg }),
+		(msg) => onProgress?.({ stage: "checkout", message: `🌿 ${msg}` }),
 	);
-	onProgress?.({ stage: "checkout", message: `${baseBranch} ← PR #${pr.number} worktrees ready` });
 
-	onProgress?.({ stage: "exploring", message: `${agent.name}: analyzing ${changedFiles.length} files...` });
+	onProgress?.({ stage: "exploring", message: `🤖 ${agent.name}: exploring ${changedFiles.length} changed files...` });
 	const exploration = await exploreCodebase(
 		agent, worktrees.headPath, changedFiles, prTitle, rawDiff,
 		(msg, current, total) => onProgress?.({ stage: "exploring", message: msg, current, total }),
 	);
-	onProgress?.({ stage: "exploring", message: `${agent.name}: exploration complete` });
+	onProgress?.({ stage: "exploring", message: `🤖 ${agent.name}: exploration complete` });
 
 	await cleanupWorktrees(bareRepoPath, pr.number, pr.owner, pr.repo).catch(() => {});
 
@@ -165,7 +161,7 @@ export async function analyzePr(options: PipelineOptions): Promise<NewprOutput>
 		fetchPrDiff(pr, token),
 		fetchPrComments(pr, token).catch(() => []),
 	]);
-	progress({ stage: "fetching", message: `#${prData.number} "${prData.title}" by ${prData.author} · +${prData.additions} −${prData.deletions} · ${prComments.length} comments` });
+	progress({ stage: "fetching", message: `#${prData.number} "${prData.title}" by ${prData.author} · +${prData.additions} −${prData.deletions} · ${prComments.length} comments`, pr_title: prData.title, pr_number: prData.number });
 
 	progress({ stage: "parsing", message: "Parsing diff..." });
 	const parsed = parseDiff(rawDiff);
@@ -259,9 +255,13 @@ export async function analyzePr(options: PipelineOptions): Promise<NewprOutput>
 	progress({ stage: "summarizing", message: `${summary.risk_level} risk · ${summary.purpose.slice(0, 60)}` });
 
 	progress({ stage: "narrating", message: `Writing narrative${enrichedTag}...` });
+	const fileDiffs = chunks.slice(0, 30).map((c) => ({
+		path: c.file_path,
+		diff: c.diff_content.length > 3000 ? `${c.diff_content.slice(0, 3000)}\n... (truncated)` : c.diff_content,
+	}));
 	const narrativePrompt = exploration
-		? buildEnrichedNarrativePrompt(prData.title, summary, groups, exploration, promptCtx)
-		: buildNarrativePrompt(prData.title, summary, groups, promptCtx);
+		? buildEnrichedNarrativePrompt(prData.title, summary, groups, exploration, promptCtx, fileDiffs)
+		: buildNarrativePrompt(prData.title, summary, groups, promptCtx, fileDiffs);
 	const narrativeResponse = await streamLlmCall(
 		client, narrativePrompt.system, narrativePrompt.user, "narrating", "Writing narrative...", progress,
 	);
@@ -297,6 +297,7 @@ export async function analyzePr(options: PipelineOptions): Promise<NewprOutput>
 			pr_title: prData.title,
 			pr_body: prData.body || undefined,
 			pr_url: prData.url,
+			pr_state: prData.state,
 			base_branch: prData.base_branch,
 			head_branch: prData.head_branch,
 			author: prData.author,

package/src/analyzer/progress.ts

@@ -17,6 +17,8 @@ export interface ProgressEvent {
 	total?: number;
 	partial_content?: string;
 	timestamp?: number;
+	pr_title?: string;
+	pr_number?: number;
 }
 
 export type ProgressCallback = (event: ProgressEvent) => void;

package/src/cli/args.ts

@@ -46,7 +46,7 @@ Options:
 
 Options (review mode):
   --repo <owner/repo>   Repository (required when using PR number only)
-  --model <model>       Override LLM model (default: anthropic/claude-sonnet-4.5)
+  --model <model>       Override LLM model (default: anthropic/claude-sonnet-4.6)
   --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)

package/src/cli/index.ts

@@ -10,8 +10,10 @@ import { analyzePr } from "../analyzer/pipeline.ts";
 import { createStderrProgress, createSilentProgress, createStreamJsonProgress } from "../analyzer/progress.ts";
 import { renderLoading, renderShell } from "../tui/render.tsx";
 import { checkForUpdate, printUpdateNotice } from "./update-check.ts";
+import { runPreflight, printPreflight } from "./preflight.ts";
+import { getVersion } from "../version.ts";
 
-const VERSION = "0.1.3";
+const VERSION = getVersion();
 
 async function main(): Promise<void> {
 	const args = parseArgs(process.argv);
@@ -51,12 +53,14 @@ async function main(): Promise<void> {
 
 	if (args.command === "web") {
 		try {
+			const preflight = await runPreflight();
+			printPreflight(preflight);
 			const config = await loadConfig({ model: args.model });
 			const token = await getGithubToken();
 			const updateInfo = await updatePromise;
 			if (updateInfo) printUpdateNotice(updateInfo);
 			const { startWebServer } = await import("../web/server.ts");
-			await startWebServer({ port: args.port ?? 3000, token, config, cartoon: args.cartoon });
+			await startWebServer({ port: args.port ?? 3000, token, config, cartoon: args.cartoon, preflight });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			process.stderr.write(`Error: ${message}\n`);
@@ -67,6 +71,8 @@ async function main(): Promise<void> {
 
 	if (args.command === "shell") {
 		try {
+			const preflight = await runPreflight();
+			printPreflight(preflight);
 			const config = await loadConfig({ model: args.model });
 			const token = await getGithubToken();
 			const updateInfo = await updatePromise;

package/src/cli/preflight.ts

@@ -0,0 +1,126 @@
+import type { AgentToolName } from "../workspace/types.ts";
+
+export interface ToolStatus {
+	name: string;
+	installed: boolean;
+	version?: string;
+	detail?: string;
+}
+
+export interface PreflightResult {
+	github: ToolStatus & { authenticated: boolean; user?: string };
+	agents: ToolStatus[];
+	openrouterKey: boolean;
+}
+
+async function which(cmd: string): Promise<string | null> {
+	try {
+		const result = await Bun.$`which ${cmd}`.text();
+		return result.trim() || null;
+	} catch {
+		return null;
+	}
+}
+
+async function getVersion(cmd: string, flag = "--version"): Promise<string | null> {
+	try {
+		const result = await Bun.$`${cmd} ${flag} 2>&1`.text();
+		const match = result.match(/[\d]+\.[\d]+[\d.]*/);
+		return match?.[0] ?? result.trim().slice(0, 30);
+	} catch {
+		return null;
+	}
+}
+
+async function checkGithubCli(): Promise<PreflightResult["github"]> {
+	const path = await which("gh");
+	if (!path) {
+		return { name: "gh", installed: false, authenticated: false, detail: "brew install gh" };
+	}
+	const version = await getVersion("gh");
+	try {
+		const status = await Bun.$`gh auth status 2>&1`.text();
+		const userMatch = status.match(/Logged in to github\.com account (\S+)/i)
+			?? status.match(/account (\S+)/i);
+		return {
+			name: "gh",
+			installed: true,
+			version: version ?? undefined,
+			authenticated: true,
+			user: userMatch?.[1]?.replace(/\s*\(.*/, ""),
+		};
+	} catch {
+		return { name: "gh", installed: true, version: version ?? undefined, authenticated: false, detail: "gh auth login" };
+	}
+}
+
+async function checkAgent(name: AgentToolName): Promise<ToolStatus> {
+	const path = await which(name);
+	if (!path) return { name, installed: false };
+	const version = await getVersion(name);
+	return { name, installed: true, version: version ?? undefined };
+}
+
+export async function runPreflight(): Promise<PreflightResult> {
+	const [github, claude, opencode, codex] = await Promise.all([
+		checkGithubCli(),
+		checkAgent("claude"),
+		checkAgent("opencode"),
+		checkAgent("codex"),
+	]);
+
+	return {
+		github,
+		agents: [claude, opencode, codex],
+		openrouterKey: !!(process.env.OPENROUTER_API_KEY || await hasStoredApiKey()),
+	};
+}
+
+async function hasStoredApiKey(): Promise<boolean> {
+	try {
+		const { readStoredConfig } = await import("../config/store.ts");
+		const stored = await readStoredConfig();
+		return !!stored.openrouter_api_key;
+	} catch {
+		return false;
+	}
+}
+
+export function printPreflight(result: PreflightResult): void {
+	const check = "\x1b[32m✓\x1b[0m";
+	const cross = "\x1b[31m✗\x1b[0m";
+	const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
+	const bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
+
+	console.log("");
+	console.log(`  ${bold("Preflight")}`);
+	console.log("");
+
+	const gh = result.github;
+	if (gh.installed && gh.authenticated) {
+		console.log(`  ${check} gh ${dim(gh.version ?? "")} ${dim(`· ${gh.user ?? ""}`)}`);
+	} else if (gh.installed) {
+		console.log(`  ${cross} gh ${dim(gh.version ?? "")} ${dim("· not authenticated")}`);
+		console.log(`    ${dim(`run: ${gh.detail}`)}`);
+	} else {
+		console.log(`  ${cross} gh ${dim("· not installed")}`);
+		console.log(`    ${dim(`run: ${gh.detail}`)}`);
+	}
+
+	for (const agent of result.agents) {
+		if (agent.installed) {
+			console.log(`  ${check} ${agent.name} ${dim(agent.version ?? "")}`);
+		} else {
+			console.log(`  ${dim("·")} ${dim(agent.name)} ${dim("not found")}`);
+		}
+	}
+
+	if (result.openrouterKey) {
+		console.log(`  ${check} OpenRouter API key`);
+	} else {
+		console.log(`  ${cross} OpenRouter API key ${dim("· not configured")}`);
+		console.log(`    ${dim("run: newpr auth")}`);
+	}
+
+	console.log("");
+}

package/src/github/fetch-pr.ts

@@ -1,15 +1,25 @@
-import type { GithubPrData, PrComment, PrCommit, PrIdentifier } from "../types/github.ts";
+import type { GithubPrData, PrComment, PrCommit, PrIdentifier, PrState } 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;
 
+	let state: PrState = "open";
+	if (json.draft) {
+		state = "draft";
+	} else if (json.merged) {
+		state = "merged";
+	} else if (json.state === "closed") {
+		state = "closed";
+	}
+
 	return {
 		number: json.number as number,
 		title: json.title as string,
 		body: (json.body as string) ?? "",
 		url: json.html_url as string,
+		state,
 		base_branch: (base?.ref as string) ?? "unknown",
 		head_branch: (head?.ref as string) ?? "unknown",
 		author: (user?.login as string) ?? "unknown",

package/src/history/store.ts

@@ -25,6 +25,7 @@ export function buildSessionRecord(id: string, data: NewprOutput): SessionRecord
 		pr_url: meta.pr_url,
 		pr_number: meta.pr_number,
 		pr_title: meta.pr_title,
+		pr_state: meta.pr_state,
 		repo: repoParts?.[1] ?? "unknown",
 		author: meta.author,
 		analyzed_at: meta.analyzed_at,

package/src/history/types.ts

@@ -3,6 +3,7 @@ export interface SessionRecord {
 	pr_url: string;
 	pr_number: number;
 	pr_title: string;
+	pr_state?: string;
 	repo: string;
 	author: string;
 	analyzed_at: string;