newpr 0.1.0

package/README.md

@@ -0,0 +1,189 @@
+# newpr
+
+AI-powered PR review tool for understanding large pull requests with 1000+ lines of changes.
+
+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.
+
+## 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)
+
+## Quick Start
+
+```bash
+bun install
+```
+
+### Option A: OpenRouter API key
+
+```bash
+export OPENROUTER_API_KEY=sk-or-...
+newpr https://github.com/owner/repo/pull/123
+```
+
+### Option B: Claude Code (no API key needed)
+
+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.
+
+```bash
+newpr https://github.com/owner/repo/pull/123
+```
+
+### Web UI
+
+```bash
+newpr --web --port 3000
+```
+
+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
+
+## 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
+```
+
+### Review mode options
+
+```
+--repo <owner/repo>   Repository (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
+--stream-json         Stream progress as NDJSON, then emit result
+--verbose             Show progress on stderr
+```
+
+### PR input formats
+
+```bash
+newpr https://github.com/owner/repo/pull/123
+newpr owner/repo#123
+newpr review 123 --repo owner/repo
+```
+
+## Architecture
+
+```
+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
+```
+
+## Analysis Pipeline
+
+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
+
+## LLM Backend
+
+newpr supports two LLM backends:
+
+| 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 |
+
+When no OpenRouter API key is configured, newpr automatically falls back to Claude Code for all LLM calls.
+
+## Codebase Exploration Agents
+
+For deep analysis beyond the diff, newpr uses an agentic coding tool to explore the actual repository:
+
+| Agent | Command | Detection |
+|-------|---------|-----------|
+| Claude Code | `claude` | `which claude` |
+| OpenCode | `opencode` | `which opencode` |
+| Codex | `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
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `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_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
+
+Persistent settings are stored in `~/.newpr/config.json`:
+
+```json
+{
+  "openrouter_api_key": "sk-or-...",
+  "model": "anthropic/claude-sonnet-4.5",
+  "language": "auto",
+  "agent": "claude",
+  "max_files": 100,
+  "timeout": 120,
+  "concurrency": 5
+}
+```
+
+## Development
+
+```bash
+bun install
+bun test              # run tests (91 tests)
+bun run typecheck     # tsc --noEmit
+bun run lint          # biome check
+bun run start         # launch CLI
+```
+
+## Requirements
+
+- [Bun](https://bun.sh) ≥ 1.3
+- GitHub CLI (`gh`) for authentication, or `GITHUB_TOKEN`
+- One of: `OPENROUTER_API_KEY` or Claude Code (`claude` CLI)
+
+## License
+
+Private

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "newpr",
+  "version": "0.1.0",
+  "description": "AI-powered large PR review tool - understand PRs with 1000+ lines of changes",
+  "module": "src/cli/index.ts",
+  "type": "module",
+  "bin": {
+    "newpr": "./src/cli/index.ts"
+  },
+  "files": [
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "bun run src/cli/index.ts",
+    "test": "bun test",
+    "lint": "bunx @biomejs/biome check .",
+    "lint:fix": "bunx @biomejs/biome check --write .",
+    "format": "bunx @biomejs/biome format --write .",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run typecheck && bun test"
+  },
+  "keywords": [
+    "pr",
+    "pull-request",
+    "code-review",
+    "ai",
+    "llm",
+    "github",
+    "cli",
+    "tui",
+    "claude",
+    "openrouter",
+    "bun"
+  ],
+  "author": "Jiwon Park <jiwon@sionic.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jiwonMe/newpr.git"
+  },
+  "homepage": "https://github.com/jiwonMe/newpr",
+  "bugs": {
+    "url": "https://github.com/jiwonMe/newpr/issues"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "latest",
+    "@types/bun": "latest",
+    "@types/react": "19.1.0",
+    "@types/react-dom": "^19.2.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
+    "@radix-ui/react-scroll-area": "^1.2.10",
+    "@radix-ui/react-slot": "^1.2.4",
+    "@radix-ui/react-tabs": "^1.1.13",
+    "@tailwindcss/cli": "^4.1.18",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "ink": "6.6.0",
+    "ink-spinner": "5.0.0",
+    "ink-text-input": "6.0.0",
+    "lucide-react": "^0.567.0",
+    "react": "19.1.0",
+    "react-dom": "19.1.0",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "tailwind-merge": "^3.4.1",
+    "tailwindcss": "^4.1.18",
+    "tailwindcss-animate": "^1.0.7"
+  }
+}

package/src/analyzer/errors.ts

@@ -0,0 +1,22 @@
+export class AnalysisError extends Error {
+	constructor(
+		message: string,
+		public readonly stage: string,
+		public override readonly cause?: Error,
+	) {
+		super(message);
+		this.name = "AnalysisError";
+	}
+}
+
+export class PartialAnalysisError extends AnalysisError {
+	constructor(
+		message: string,
+		stage: string,
+		public readonly failedFiles: string[],
+		cause?: Error,
+	) {
+		super(message, stage, cause);
+		this.name = "PartialAnalysisError";
+	}
+}

package/src/analyzer/pipeline.ts

@@ -0,0 +1,299 @@
+import type { NewprConfig } from "../types/config.ts";
+import type { DiffChunk } from "../types/diff.ts";
+import type { PrIdentifier } from "../types/github.ts";
+import type { FileChange, FileGroup, NewprOutput, PrSummary } from "../types/output.ts";
+import type { ExplorationResult } from "../workspace/types.ts";
+import type { AgentToolName } from "../workspace/types.ts";
+import { parseDiff } from "../diff/parser.ts";
+import { chunkDiff } from "../diff/chunker.ts";
+import { fetchPrData } from "../github/fetch-pr.ts";
+import { fetchPrDiff } from "../github/fetch-diff.ts";
+import { createLlmClient, type LlmClient, type LlmResponse } from "../llm/client.ts";
+import {
+	buildFileSummaryPrompt,
+	buildGroupingPrompt,
+	buildOverallSummaryPrompt,
+	buildNarrativePrompt,
+	buildEnrichedSummaryPrompt,
+	buildEnrichedNarrativePrompt,
+	type FileSummaryInput,
+	type PromptContext,
+} from "../llm/prompts.ts";
+import {
+	parseFileSummaries,
+	parseGroups,
+	parseSummary,
+	parseNarrative,
+} from "../llm/response-parser.ts";
+import { ensureRepo } from "../workspace/repo-cache.ts";
+import { createWorktrees, cleanupWorktrees } from "../workspace/worktree.ts";
+import { requireAgent } from "../workspace/agent.ts";
+import { exploreCodebase } from "../workspace/explore.ts";
+import type { ProgressCallback, ProgressStage } from "./progress.ts";
+import { createSilentProgress } from "./progress.ts";
+
+async function streamLlmCall(
+	client: LlmClient,
+	system: string,
+	user: string,
+	stage: ProgressStage,
+	message: string,
+	progress: ProgressCallback,
+): Promise<LlmResponse> {
+	return client.completeStream(system, user, (_chunk, accumulated) => {
+		progress({ stage, message, partial_content: accumulated });
+	});
+}
+
+interface PipelineOptions {
+	pr: PrIdentifier;
+	token: string;
+	config: NewprConfig;
+	onProgress?: ProgressCallback;
+	noClone?: boolean;
+	preferredAgent?: AgentToolName;
+}
+
+async function analyzeFileChunkBatch(
+	client: LlmClient,
+	chunks: DiffChunk[],
+	ctx?: import("../llm/prompts.ts").PromptContext,
+): Promise<Array<{ path: string; summary: string }>> {
+	const { system, user } = buildFileSummaryPrompt(chunks, ctx);
+	const response = await client.complete(system, user);
+	return parseFileSummaries(response.content);
+}
+
+function batchChunks(chunks: DiffChunk[], batchSize: number): DiffChunk[][] {
+	const batches: DiffChunk[][] = [];
+	for (let i = 0; i < chunks.length; i += batchSize) {
+		batches.push(chunks.slice(i, i + batchSize));
+	}
+	return batches;
+}
+
+async function runExploration(
+	pr: PrIdentifier,
+	token: string,
+	baseBranch: string,
+	changedFiles: string[],
+	prTitle: string,
+	rawDiff: string,
+	preferredAgent?: AgentToolName,
+	onProgress?: ProgressCallback,
+): 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: `${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 }),
+	);
+	onProgress?.({ stage: "checkout", message: `${baseBranch} ← PR #${pr.number} worktrees ready` });
+
+	onProgress?.({ stage: "exploring", message: `${agent.name}: analyzing ${changedFiles.length} 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` });
+
+	await cleanupWorktrees(bareRepoPath, pr.number, pr.owner, pr.repo).catch(() => {});
+
+	return exploration;
+}
+
+const MAX_EXPLORE_RETRIES = 2;
+
+async function tryExploreCodebase(
+	pr: PrIdentifier,
+	token: string,
+	baseBranch: string,
+	changedFiles: string[],
+	prTitle: string,
+	rawDiff: string,
+	preferredAgent?: AgentToolName,
+	onProgress?: ProgressCallback,
+): Promise<ExplorationResult | null> {
+	for (let attempt = 1; attempt <= MAX_EXPLORE_RETRIES; attempt++) {
+		try {
+			return await runExploration(
+				pr, token, baseBranch, changedFiles, prTitle, rawDiff,
+				preferredAgent, onProgress,
+			);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			if (attempt < MAX_EXPLORE_RETRIES) {
+				onProgress?.({
+					stage: "exploring",
+					message: `Attempt ${attempt} failed: ${msg}. Retrying...`,
+				});
+				await cleanupWorktrees(
+					await ensureRepo(pr.owner, pr.repo, token).catch(() => ""),
+					pr.number, pr.owner, pr.repo,
+				).catch(() => {});
+			} else {
+				onProgress?.({
+					stage: "exploring",
+					message: `Exploration failed after ${MAX_EXPLORE_RETRIES} attempts: ${msg}`,
+				});
+			}
+		}
+	}
+	return null;
+}
+
+export async function analyzePr(options: PipelineOptions): Promise<NewprOutput> {
+	const { pr, token, config, noClone, preferredAgent } = options;
+	const progress = options.onProgress ?? createSilentProgress();
+	const client = createLlmClient({
+		api_key: config.openrouter_api_key,
+		model: config.model,
+		timeout: config.timeout,
+	});
+
+	progress({ stage: "fetching", message: "Fetching PR data and diff..." });
+	const [prData, rawDiff] = await Promise.all([
+		fetchPrData(pr, token),
+		fetchPrDiff(pr, token),
+	]);
+	progress({ stage: "fetching", message: `#${prData.number} "${prData.title}" by ${prData.author} · +${prData.additions} −${prData.deletions}` });
+
+	progress({ stage: "parsing", message: "Parsing diff..." });
+	const parsed = parseDiff(rawDiff);
+	const allChunks = chunkDiff(parsed);
+	const chunks = allChunks.slice(0, config.max_files);
+	const wasTruncated = allChunks.length > config.max_files;
+	const changedFiles = chunks.map((c) => c.file_path);
+	const totalAdd = chunks.reduce((s, c) => s + c.additions, 0);
+	const totalDel = chunks.reduce((s, c) => s + c.deletions, 0);
+	progress({ stage: "parsing", message: `${chunks.length} files · +${totalAdd} −${totalDel}${wasTruncated ? ` (${allChunks.length - config.max_files} skipped)` : ""}` });
+
+	let exploration: ExplorationResult | null = null;
+	if (!noClone) {
+		exploration = await tryExploreCodebase(
+			pr, token, prData.base_branch, changedFiles, prData.title, rawDiff,
+			preferredAgent, progress,
+		);
+	}
+
+	const promptCtx: PromptContext = { commits: prData.commits, language: config.language };
+	const enrichedTag = exploration ? " + codebase context" : "";
+
+	progress({
+		stage: "analyzing",
+		message: `Analyzing ${chunks.length} files${enrichedTag}...`,
+	});
+
+	const fileBatchSize = 10;
+	const batches = batchChunks(chunks, fileBatchSize);
+	const allFileSummaries: Array<{ path: string; summary: string }> = [];
+
+	for (let i = 0; i < batches.length; i++) {
+		const batchFiles = batches.slice(i, i + config.concurrency)
+			.flat()
+			.map((c) => c.file_path.split("/").pop() ?? c.file_path);
+		progress({
+			stage: "analyzing",
+			message: batchFiles.join(", "),
+			current: Math.min((i + 1) * fileBatchSize, chunks.length),
+			total: chunks.length,
+		});
+
+		const concurrentBatches = batches.slice(i, i + config.concurrency);
+		const results = await Promise.all(
+			concurrentBatches.map((batch) => analyzeFileChunkBatch(client, batch, promptCtx)),
+		);
+		allFileSummaries.push(...results.flat());
+		i += config.concurrency - 1;
+	}
+	progress({ stage: "analyzing", message: `${allFileSummaries.length} files summarized${enrichedTag}` });
+
+	progress({ stage: "grouping", message: `Grouping ${chunks.length} files by purpose...` });
+	const fileSummaryInputs: FileSummaryInput[] = chunks.map((chunk) => {
+		const summary = allFileSummaries.find((s) => s.path === chunk.file_path);
+		return {
+			path: chunk.file_path,
+			summary: summary?.summary ?? "No summary available",
+			status: chunk.status,
+		};
+	});
+
+	const { system: groupSystem, user: groupUser } = buildGroupingPrompt(fileSummaryInputs, promptCtx);
+	const groupResponse = await streamLlmCall(
+		client, groupSystem, groupUser, "grouping", "Grouping files...", progress,
+	);
+	const groups: FileGroup[] = parseGroups(groupResponse.content);
+	progress({ stage: "grouping", message: `${groups.length} groups: ${groups.map((g) => g.name).join(", ")}` });
+
+	progress({ stage: "summarizing", message: `Generating summary${enrichedTag}...` });
+	const summaryPrompt = exploration
+		? buildEnrichedSummaryPrompt(prData.title, groups, allFileSummaries, exploration, promptCtx)
+		: buildOverallSummaryPrompt(prData.title, groups, allFileSummaries, promptCtx);
+	const summaryResponse = await streamLlmCall(
+		client, summaryPrompt.system, summaryPrompt.user, "summarizing", "Generating summary...", progress,
+	);
+	const summary: PrSummary = parseSummary(summaryResponse.content);
+	progress({ stage: "summarizing", message: `${summary.risk_level} risk · ${summary.purpose.slice(0, 60)}` });
+
+	progress({ stage: "narrating", message: `Writing narrative${enrichedTag}...` });
+	const narrativePrompt = exploration
+		? buildEnrichedNarrativePrompt(prData.title, summary, groups, exploration, promptCtx)
+		: buildNarrativePrompt(prData.title, summary, groups, promptCtx);
+	const narrativeResponse = await streamLlmCall(
+		client, narrativePrompt.system, narrativePrompt.user, "narrating", "Writing narrative...", progress,
+	);
+	const narrative = parseNarrative(narrativeResponse.content);
+	progress({ stage: "narrating", message: `${narrative.split("\n").length} lines` });
+
+	progress({ stage: "done", message: "Analysis complete." });
+
+	const fileGroupsMap = new Map<string, string[]>();
+	for (const group of groups) {
+		for (const filePath of group.files) {
+			const existing = fileGroupsMap.get(filePath) ?? [];
+			existing.push(group.name);
+			fileGroupsMap.set(filePath, existing);
+		}
+	}
+
+	const files: FileChange[] = chunks.map((chunk) => {
+		const summaryEntry = allFileSummaries.find((s) => s.path === chunk.file_path);
+		return {
+			path: chunk.file_path,
+			status: chunk.status,
+			additions: chunk.additions,
+			deletions: chunk.deletions,
+			summary: summaryEntry?.summary ?? "No summary available",
+			groups: fileGroupsMap.get(chunk.file_path) ?? ["Ungrouped"],
+		};
+	});
+
+	return {
+		meta: {
+			pr_number: prData.number,
+			pr_title: prData.title,
+			pr_url: prData.url,
+			base_branch: prData.base_branch,
+			head_branch: prData.head_branch,
+			author: prData.author,
+			author_avatar: prData.author_avatar,
+			author_url: prData.author_url,
+			total_files_changed: prData.changed_files,
+			total_additions: prData.additions,
+			total_deletions: prData.deletions,
+			analyzed_at: new Date().toISOString(),
+			model_used: config.model,
+		},
+		summary,
+		groups,
+		files,
+		narrative,
+	};
+}

package/src/analyzer/progress.ts

@@ -0,0 +1,69 @@
+export type ProgressStage =
+	| "fetching"
+	| "cloning"
+	| "checkout"
+	| "exploring"
+	| "parsing"
+	| "analyzing"
+	| "grouping"
+	| "summarizing"
+	| "narrating"
+	| "done";
+
+export interface ProgressEvent {
+	stage: ProgressStage;
+	message: string;
+	current?: number;
+	total?: number;
+	partial_content?: string;
+	timestamp?: number;
+}
+
+export type ProgressCallback = (event: ProgressEvent) => void;
+
+const STAGE_ORDER: ProgressStage[] = [
+	"fetching", "parsing", "cloning", "checkout", "exploring",
+	"analyzing", "grouping", "summarizing", "narrating", "done",
+];
+
+export function stageIndex(stage: ProgressStage): number {
+	return STAGE_ORDER.indexOf(stage);
+}
+
+export function allStages(): ProgressStage[] {
+	return [...STAGE_ORDER];
+}
+
+export function createStderrProgress(): ProgressCallback {
+	return (event: ProgressEvent) => {
+		const prefix = "[newpr]";
+		const progress =
+			event.current !== undefined && event.total !== undefined
+				? ` (${event.current}/${event.total})`
+				: "";
+		process.stderr.write(`${prefix} ${event.stage}: ${event.message}${progress}\n`);
+	};
+}
+
+export function createSilentProgress(): ProgressCallback {
+	return () => {};
+}
+
+export function createStreamJsonProgress(): ProgressCallback {
+	const startTime = Date.now();
+	return (event: ProgressEvent) => {
+		const line = JSON.stringify({
+			type: "progress",
+			timestamp: new Date().toISOString(),
+			elapsed_ms: Date.now() - startTime,
+			stage: event.stage,
+			stage_index: stageIndex(event.stage),
+			total_stages: STAGE_ORDER.length,
+			message: event.message,
+		current: event.current ?? null,
+		total: event.total ?? null,
+		partial_content: event.partial_content ?? null,
+		});
+		process.stdout.write(`${line}\n`);
+	};
+}