newpr 0.1.0

package/src/tui/panels/StoryPanel.tsx

@@ -0,0 +1,296 @@
+import React, { useState, useMemo, useCallback } from "react";
+import { Box, Text, useInput, useStdout } from "ink";
+import type { NewprOutput, FileGroup, FileChange } from "../../types/output.ts";
+import {
+	parseNarrativeAnchors,
+	type NarrativeAnchor,
+} from "../narrative-parser.ts";
+import { T, STATUS_STYLE, TYPE_STYLE } from "../theme.ts";
+
+interface DetailTarget {
+	kind: "group" | "file";
+	group?: FileGroup;
+	files: FileChange[];
+	file?: FileChange;
+}
+
+function resolveDetail(
+	anchor: NarrativeAnchor,
+	groups: FileGroup[],
+	files: FileChange[],
+): DetailTarget | null {
+	if (anchor.kind === "group") {
+		const group = groups.find((g) => g.name === anchor.id);
+		if (!group) return null;
+		const groupFiles = files.filter((f) => group.files.includes(f.path));
+		return { kind: "group", group, files: groupFiles };
+	}
+	const file = files.find((f) => f.path === anchor.id);
+	if (!file) return null;
+	return { kind: "file", file, files: [file] };
+}
+
+function renderNarrativeLine(
+	line: string,
+	lineIndex: number,
+	anchors: NarrativeAnchor[],
+	activeAnchorIdx: number,
+	allAnchors: NarrativeAnchor[],
+): React.ReactNode {
+	const lineAnchors = anchors.filter((a) => a.lineIndex === lineIndex);
+	if (lineAnchors.length === 0) {
+		return renderPlainLine(line);
+	}
+
+	const parts: React.ReactNode[] = [];
+	let cursor = 0;
+	let key = 0;
+
+	for (const anchor of lineAnchors) {
+		if (anchor.startCol > cursor) {
+			parts.push(
+				<Text key={key++} color={T.text}>
+					{line.slice(cursor, anchor.startCol)}
+				</Text>,
+			);
+		}
+
+		const globalIdx = allAnchors.indexOf(anchor);
+		const isActive = globalIdx === activeAnchorIdx;
+		const label = line.slice(anchor.startCol, anchor.endCol);
+
+		parts.push(
+			<Text key={key++} inverse={isActive} bold={isActive} color={isActive ? T.textBold : T.primaryBold} underline={!isActive}>
+				{label}
+			</Text>,
+		);
+
+		cursor = anchor.endCol;
+	}
+
+	if (cursor < line.length) {
+		parts.push(<Text key={key++} color={T.text}>{line.slice(cursor)}</Text>);
+	}
+
+	return <Text>{...parts}</Text>;
+}
+
+function renderPlainLine(line: string): React.ReactNode {
+	if (line.startsWith("### ")) return <Text bold color={T.primaryBold}>{line.slice(4)}</Text>;
+	if (line.startsWith("## ")) return <Text bold color={T.primary} underline>{line.slice(3)}</Text>;
+	if (line.startsWith("# ")) return <Text bold color={T.primary} underline>{line.slice(2)}</Text>;
+	if (line.startsWith("- ") || line.startsWith("* ")) {
+		return <Text><Text color={T.primary}>  •</Text> {line.slice(2)}</Text>;
+	}
+	return <Text color={T.text}>{line}</Text>;
+}
+
+function DetailPane({
+	target,
+	detailScroll,
+	height,
+}: { target: DetailTarget | null; detailScroll: number; height: number }) {
+	if (!target) {
+		return (
+			<Box flexDirection="column" paddingX={1} paddingY={1}>
+				<Text color={T.faint} italic>Navigate to an anchor</Text>
+				<Text color={T.faint} italic>to see details here</Text>
+				<Text> </Text>
+				<Text color={T.faint}>]/[ next/prev anchor</Text>
+				<Text color={T.faint}>Enter to pin</Text>
+			</Box>
+		);
+	}
+
+	if (target.kind === "group" && target.group) {
+		const g = target.group;
+		const typeColor = TYPE_STYLE[g.type]?.color ?? T.muted;
+		const lines: React.ReactNode[] = [
+			<Box key="name" gap={1}>
+				<Text bold color={typeColor}>{g.name}</Text>
+				<Text color={T.muted}>({g.type})</Text>
+			</Box>,
+			<Text key="desc" color={T.muted} wrap="wrap">{g.description}</Text>,
+			<Text key="sep" color={T.faint}>{"─".repeat(28)}</Text>,
+		];
+
+		for (const f of target.files) {
+			const s = STATUS_STYLE[f.status] ?? { icon: "?", color: T.muted };
+			lines.push(
+				<Box key={`f-${f.path}`} flexDirection="column">
+					<Box gap={1}>
+						<Text color={s.color} bold>{s.icon}</Text>
+						<Text color={T.text}>{f.path.split("/").pop()}</Text>
+						<Text color={T.added}>+{f.additions}</Text>
+						<Text color={T.deleted}>-{f.deletions}</Text>
+					</Box>
+					<Text color={T.muted} wrap="wrap">  {f.summary}</Text>
+				</Box>,
+			);
+		}
+
+		const visible = lines.slice(detailScroll, detailScroll + height - 1);
+		return <Box flexDirection="column" paddingX={1}>{...visible}</Box>;
+	}
+
+	if (target.kind === "file" && target.file) {
+		const f = target.file;
+		const s = STATUS_STYLE[f.status] ?? { icon: "?", color: T.muted };
+		return (
+			<Box flexDirection="column" paddingX={1}>
+				<Box gap={1}>
+					<Text color={s.color} bold>{s.icon}</Text>
+					<Text bold color={T.text}>{f.path}</Text>
+				</Box>
+				<Box gap={1}>
+					<Text color={T.added}>+{f.additions}</Text>
+					<Text color={T.deleted}>-{f.deletions}</Text>
+					<Text color={T.faint}>[{f.groups.join(", ")}]</Text>
+				</Box>
+				<Text color={T.faint}>{"─".repeat(28)}</Text>
+				<Text color={T.muted} wrap="wrap">{f.summary}</Text>
+			</Box>
+		);
+	}
+
+	return null;
+}
+
+export function StoryPanel({
+	data,
+	isFocused,
+	viewportHeight,
+}: { data: NewprOutput; isFocused: boolean; viewportHeight: number }) {
+	const { stdout } = useStdout();
+	const termWidth = stdout?.columns ?? 80;
+	const leftWidth = Math.max(30, Math.floor(termWidth * 0.62));
+	const rightWidth = Math.max(20, termWidth - leftWidth - 4);
+
+	const parsed = useMemo(() => parseNarrativeAnchors(data.narrative), [data.narrative]);
+
+	const [scrollOffset, setScrollOffset] = useState(0);
+	const [activeAnchorIdx, setActiveAnchorIdx] = useState(0);
+	const [pinned, setPinned] = useState(false);
+	const [focusPane, setFocusPane] = useState<"narrative" | "detail">("narrative");
+	const [detailScroll, setDetailScroll] = useState(0);
+
+	const { displayLines, allAnchors } = parsed;
+	const maxScroll = Math.max(0, displayLines.length - viewportHeight + 3);
+
+	const currentAnchor = allAnchors[activeAnchorIdx] ?? null;
+	const detailTarget = useMemo(
+		() => currentAnchor ? resolveDetail(currentAnchor, data.groups, data.files) : null,
+		[currentAnchor, data.groups, data.files],
+	);
+
+	const jumpToAnchor = useCallback((idx: number) => {
+		const anchor = allAnchors[idx];
+		if (!anchor) return;
+		setActiveAnchorIdx(idx);
+		setDetailScroll(0);
+		if (anchor.lineIndex < scrollOffset || anchor.lineIndex >= scrollOffset + viewportHeight - 3) {
+			setScrollOffset(Math.max(0, Math.min(anchor.lineIndex - 2, maxScroll)));
+		}
+	}, [allAnchors, scrollOffset, viewportHeight, maxScroll]);
+
+	useInput(
+		(input, key) => {
+			if (key.tab) {
+				setFocusPane((p) => p === "narrative" ? "detail" : "narrative");
+				return;
+			}
+
+			if (focusPane === "narrative") {
+				let explicitNav = false;
+
+				if (key.upArrow || input === "k") {
+					setScrollOffset((s) => Math.max(0, s - 1));
+				} else if (key.downArrow || input === "j") {
+					setScrollOffset((s) => Math.min(maxScroll, s + 1));
+				} else if (input === "]") {
+					explicitNav = true;
+					const next = Math.min(allAnchors.length - 1, activeAnchorIdx + 1);
+					jumpToAnchor(next);
+				} else if (input === "[") {
+					explicitNav = true;
+					const prev = Math.max(0, activeAnchorIdx - 1);
+					jumpToAnchor(prev);
+				} else if (key.return) {
+					setPinned((p) => !p);
+				}
+
+				if (!pinned && !explicitNav && !key.return && allAnchors.length > 0) {
+					const visibleStart = scrollOffset;
+					const visibleEnd = scrollOffset + viewportHeight - 3;
+					const midLine = Math.floor((visibleStart + visibleEnd) / 2);
+					const closest = allAnchors.reduce((best, a, i) => {
+						const dist = Math.abs(a.lineIndex - midLine);
+						const bestDist = best.idx === -1 ? Infinity : Math.abs(allAnchors[best.idx]!.lineIndex - midLine);
+						return dist < bestDist ? { idx: i, dist } : best;
+					}, { idx: -1, dist: Infinity });
+					if (closest.idx >= 0 && closest.idx !== activeAnchorIdx) {
+						setActiveAnchorIdx(closest.idx);
+						setDetailScroll(0);
+					}
+				}
+			} else {
+				if (key.upArrow || input === "k") {
+					setDetailScroll((s) => Math.max(0, s - 1));
+				} else if (key.downArrow || input === "j") {
+					setDetailScroll((s) => s + 1);
+				} else if (key.escape) {
+					setFocusPane("narrative");
+				}
+			}
+		},
+		{ isActive: isFocused },
+	);
+
+	const visibleCount = Math.max(1, viewportHeight - 3);
+	const visible = displayLines.slice(scrollOffset, scrollOffset + visibleCount);
+	const canScrollUp = scrollOffset > 0;
+	const canScrollDown = scrollOffset < maxScroll;
+
+	const anchorInfo = allAnchors.length > 0
+		? `${activeAnchorIdx + 1}/${allAnchors.length}`
+		: "no anchors";
+
+	return (
+		<Box flexDirection="column">
+			<Box gap={1} paddingX={1}>
+				<Text bold color={T.primary}>Story</Text>
+				<Text color={T.faint}>│</Text>
+				<Text color={T.muted}>
+					Anchor {anchorInfo}
+					{pinned ? <Text color={T.accent}> [pinned]</Text> : ""}
+				</Text>
+				<Text color={T.faint}>│</Text>
+				<Text color={focusPane === "narrative" ? T.primary : T.muted} bold={focusPane === "narrative"}>
+					Narrative
+				</Text>
+				<Text color={focusPane === "detail" ? T.primary : T.muted} bold={focusPane === "detail"}>
+					Detail
+				</Text>
+			</Box>
+
+			<Box>
+				<Box flexDirection="column" width={leftWidth} borderStyle="single" borderColor={focusPane === "narrative" ? T.primary : T.border} borderRight borderLeft={false} borderTop={false} borderBottom={false}>
+					{canScrollUp && <Text color={T.faint}> ↑</Text>}
+					{visible.map((line, vi) => {
+						const lineIdx = scrollOffset + vi;
+						return (
+							<Box key={lineIdx} paddingX={1}>
+								{renderNarrativeLine(line, lineIdx, allAnchors, activeAnchorIdx, allAnchors)}
+							</Box>
+						);
+					})}
+					{canScrollDown && <Text color={T.faint}> ↓</Text>}
+				</Box>
+
+				<Box flexDirection="column" width={rightWidth}>
+					<DetailPane target={detailTarget} detailScroll={detailScroll} height={viewportHeight - 2} />
+				</Box>
+			</Box>
+		</Box>
+	);
+}

package/src/tui/panels/SummaryPanel.tsx

@@ -0,0 +1,59 @@
+import { Box, Text } from "ink";
+import type { PrSummary, PrMeta } from "../../types/output.ts";
+import { T, RISK_COLORS } from "../theme.ts";
+
+const RISK_ICONS: Record<string, string> = {
+	low: "●",
+	medium: "◐",
+	high: "◉",
+};
+
+function Field({ label, value }: { label: string; value: string }) {
+	return (
+		<Box gap={1}>
+			<Box width={10}>
+				<Text bold color={T.primary}>{label}:</Text>
+			</Box>
+			<Text color={T.text} wrap="wrap">{value}</Text>
+		</Box>
+	);
+}
+
+export function SummaryPanel({ summary, meta }: { summary: PrSummary; meta: PrMeta }) {
+	const riskColor = RISK_COLORS[summary.risk_level] ?? T.warn;
+	const riskIcon = RISK_ICONS[summary.risk_level] ?? "●";
+
+	return (
+		<Box flexDirection="column" paddingX={2} paddingY={1} gap={1}>
+			<Text bold color={T.primary}>◈ PR Summary</Text>
+
+			<Box flexDirection="column">
+				<Field label="Purpose" value={summary.purpose} />
+				<Field label="Scope" value={summary.scope} />
+				<Field label="Impact" value={summary.impact} />
+				<Box gap={1}>
+					<Box width={10}>
+						<Text bold color={T.primary}>Risk:</Text>
+					</Box>
+					<Text color={riskColor} bold>{riskIcon} {summary.risk_level.toUpperCase()}</Text>
+				</Box>
+			</Box>
+
+			<Box flexDirection="column" marginTop={1}>
+				<Text bold color={T.faint}>─── Analysis Info ───</Text>
+				<Box gap={1}>
+					<Text color={T.muted}>Model:</Text>
+					<Text color={T.text}>{meta.model_used}</Text>
+				</Box>
+				<Box gap={1}>
+					<Text color={T.muted}>Time:</Text>
+					<Text color={T.text}>{new Date(meta.analyzed_at).toLocaleString()}</Text>
+				</Box>
+				<Box gap={1}>
+					<Text color={T.muted}>URL:</Text>
+					<Text color={T.primary} underline>{meta.pr_url}</Text>
+				</Box>
+			</Box>
+		</Box>
+	);
+}

package/src/tui/panels/WalkthroughPanel.tsx

@@ -0,0 +1,149 @@
+import React, { useState, useMemo } from "react";
+import { Box, Text, useInput } from "ink";
+import type { NewprOutput, FileChange } from "../../types/output.ts";
+import { parseNarrativeAnchors, buildWalkthrough } from "../narrative-parser.ts";
+import { T, STATUS_STYLE, TYPE_STYLE } from "../theme.ts";
+
+function FileRow({ file }: { file: FileChange }) {
+	const s = STATUS_STYLE[file.status] ?? { icon: "?", color: T.muted };
+	return (
+		<Box flexDirection="column" marginLeft={2}>
+			<Box gap={1}>
+				<Text color={s.color} bold>{s.icon}</Text>
+				<Text color={T.text}>{file.path}</Text>
+				<Text color={T.added}>+{file.additions}</Text>
+				<Text color={T.deleted}>-{file.deletions}</Text>
+			</Box>
+			<Text color={T.muted} wrap="wrap">    {file.summary}</Text>
+		</Box>
+	);
+}
+
+export function WalkthroughPanel({
+	data,
+	isFocused,
+	viewportHeight,
+}: { data: NewprOutput; isFocused: boolean; viewportHeight: number }) {
+	const parsed = useMemo(() => parseNarrativeAnchors(data.narrative), [data.narrative]);
+	const steps = useMemo(
+		() => buildWalkthrough(parsed, data.groups, data.files),
+		[parsed, data.groups, data.files],
+	);
+
+	const [currentStep, setCurrentStep] = useState(0);
+	const [scrollOffset, setScrollOffset] = useState(0);
+
+	const step = steps[currentStep];
+
+	useInput(
+		(input, key) => {
+			if (key.rightArrow || input === "l" || input === "n") {
+				setCurrentStep((s) => Math.min(steps.length - 1, s + 1));
+				setScrollOffset(0);
+			} else if (key.leftArrow || input === "h" || input === "p") {
+				setCurrentStep((s) => Math.max(0, s - 1));
+				setScrollOffset(0);
+			} else if (key.downArrow || input === "j") {
+				setScrollOffset((s) => s + 1);
+			} else if (key.upArrow || input === "k") {
+				setScrollOffset((s) => Math.max(0, s - 1));
+			}
+		},
+		{ isActive: isFocused },
+	);
+
+	if (!step || steps.length === 0) {
+		return (
+			<Box paddingX={2} paddingY={1}>
+				<Text dimColor>No walkthrough steps available.</Text>
+			</Box>
+		);
+	}
+
+	const progressPct = steps.length > 1
+		? Math.round((currentStep / (steps.length - 1)) * 100)
+		: 100;
+
+	const progressBarWidth = 20;
+	const filled = Math.round((progressPct / 100) * progressBarWidth);
+	const progressBar = "█".repeat(filled) + "░".repeat(progressBarWidth - filled);
+
+	const contentLines: React.ReactNode[] = [];
+
+	contentLines.push(
+		<Box key="narrative-header" gap={1} marginBottom={1}>
+			<Text bold color={T.primaryBold}>Narrative</Text>
+		</Box>,
+	);
+
+	for (let li = 0; li < step.block.lines.length; li++) {
+		const line = step.block.lines[li]!;
+		contentLines.push(
+			<Box key={`line-${li}`} paddingX={1}>
+				<Text color={T.text} wrap="wrap">{line}</Text>
+			</Box>,
+		);
+	}
+
+	if (step.relatedGroups.length > 0) {
+		contentLines.push(
+			<Box key="groups-header" gap={1} marginTop={1}>
+				<Text bold color={T.primary}>Groups</Text>
+			</Box>,
+		);
+
+		for (const g of step.relatedGroups) {
+			const typeColor = TYPE_STYLE[g.type]?.color ?? T.muted;
+			contentLines.push(
+				<Box key={`g-${g.name}`} gap={1} marginLeft={1}>
+					<Text color={typeColor} bold>{g.name}</Text>
+					<Text color={T.muted}>({g.type})</Text>
+					<Text color={T.muted}>— {g.description}</Text>
+				</Box>,
+			);
+		}
+	}
+
+	if (step.relatedFiles.length > 0) {
+		contentLines.push(
+			<Box key="files-header" gap={1} marginTop={1}>
+				<Text bold color={T.accent}>Files ({step.relatedFiles.length})</Text>
+			</Box>,
+		);
+
+		for (const f of step.relatedFiles) {
+			contentLines.push(<FileRow key={`f-${f.path}`} file={f} />);
+		}
+	}
+
+	const visibleHeight = Math.max(1, viewportHeight - 5);
+	const visible = contentLines.slice(scrollOffset, scrollOffset + visibleHeight);
+	const canScrollDown = scrollOffset + visibleHeight < contentLines.length;
+
+	return (
+		<Box flexDirection="column" paddingX={1}>
+			<Box gap={1} marginBottom={1}>
+				<Text bold color={T.primary}>Walkthrough</Text>
+				<Text color={T.faint}>│</Text>
+				<Text color={T.muted}>Step {currentStep + 1}/{steps.length}</Text>
+				<Text color={T.faint}>│</Text>
+				<Text color={T.primary}>{progressBar}</Text>
+				<Text color={T.muted}>{progressPct}%</Text>
+			</Box>
+
+			{visible}
+
+			<Box marginTop={1} gap={1}>
+				{scrollOffset > 0 && <Text color={T.faint}>↑</Text>}
+				{canScrollDown && <Text color={T.faint}>↓</Text>}
+				<Text color={T.faint}>│</Text>
+				<Text color={T.primaryBold} bold>←/h</Text>
+				<Text color={T.muted}>prev</Text>
+				<Text color={T.primaryBold} bold>→/l</Text>
+				<Text color={T.muted}>next</Text>
+				<Text color={T.primaryBold} bold>j/k</Text>
+				<Text color={T.muted}>scroll</Text>
+			</Box>
+		</Box>
+	);
+}

package/src/tui/render.tsx

@@ -0,0 +1,62 @@
+import { useState, useEffect, useRef } from "react";
+import { render } from "ink";
+import type { NewprOutput } from "../types/output.ts";
+import type { NewprConfig } from "../types/config.ts";
+import type { ProgressEvent } from "../analyzer/progress.ts";
+import { App } from "./App.tsx";
+import { LoadingTimeline, buildStepLog } from "./Loading.tsx";
+import { Shell } from "./Shell.tsx";
+
+function LoadingApp({
+	resolve,
+}: { resolve: (handlers: LoadingHandlers) => void }) {
+	const [data, setData] = useState<NewprOutput | null>(null);
+	const eventsRef = useRef<ProgressEvent[]>([]);
+	const [steps, setSteps] = useState(buildStepLog([]));
+	const [elapsed, setElapsed] = useState(0);
+	const startRef = useRef(Date.now());
+
+	useEffect(() => {
+		const timer = setInterval(() => {
+			setElapsed(Date.now() - startRef.current);
+		}, 500);
+		return () => clearInterval(timer);
+	}, []);
+
+	useEffect(() => {
+		resolve({
+			update(event: ProgressEvent) {
+				eventsRef.current = [...eventsRef.current, event];
+				setSteps(buildStepLog(eventsRef.current));
+			},
+			finish(result: NewprOutput) {
+				setData(result);
+			},
+		});
+	}, [resolve]);
+
+	if (data) {
+		return <App data={data} />;
+	}
+
+	return <LoadingTimeline steps={steps} elapsed={elapsed} />;
+}
+
+export interface LoadingHandlers {
+	update: (event: ProgressEvent) => void;
+	finish: (data: NewprOutput) => void;
+}
+
+export function renderTui(data: NewprOutput): void {
+	render(<App data={data} />);
+}
+
+export function renderLoading(): Promise<LoadingHandlers> {
+	return new Promise<LoadingHandlers>((resolve) => {
+		render(<LoadingApp resolve={resolve} />);
+	});
+}
+
+export function renderShell(token: string, config: NewprConfig, initialPr?: string): void {
+	render(<Shell token={token} config={config} initialPr={initialPr} />);
+}

package/src/tui/theme.ts

@@ -0,0 +1,44 @@
+export const T = {
+	primary: "#5fafaf",
+	primaryBold: "#87d7d7",
+
+	text: "#c0c0c0",
+	textBold: "#e0e0e0",
+	muted: "#808080",
+	faint: "#585858",
+	border: "#444444",
+
+	accent: "#d7af5f",
+
+	ok: "#5faf5f",
+	warn: "#d7af5f",
+	error: "#d75f5f",
+
+	added: "#5faf5f",
+	deleted: "#d75f5f",
+	modified: "#d7af5f",
+	renamed: "#5f87af",
+} as const;
+
+export const STATUS_STYLE: Record<string, { icon: string; color: string }> = {
+	added: { icon: "A", color: T.added },
+	modified: { icon: "M", color: T.modified },
+	deleted: { icon: "D", color: T.deleted },
+	renamed: { icon: "R", color: T.renamed },
+};
+
+export const TYPE_STYLE: Record<string, { icon: string; color: string }> = {
+	feature: { icon: "~", color: T.primary },
+	refactor: { icon: "~", color: T.muted },
+	bugfix: { icon: "~", color: T.error },
+	chore: { icon: "~", color: T.faint },
+	docs: { icon: "~", color: T.muted },
+	test: { icon: "~", color: T.ok },
+	config: { icon: "~", color: T.accent },
+};
+
+export const RISK_COLORS: Record<string, string> = {
+	low: T.ok,
+	medium: T.warn,
+	high: T.error,
+};

package/src/types/config.ts

@@ -0,0 +1,19 @@
+import type { AgentToolName } from "../workspace/types.ts";
+
+export interface NewprConfig {
+	openrouter_api_key: string;
+	model: string;
+	max_files: number;
+	timeout: number;
+	concurrency: number;
+	language: string;
+	agent?: AgentToolName;
+}
+
+export const DEFAULT_CONFIG: Omit<NewprConfig, "openrouter_api_key"> = {
+	model: "anthropic/claude-sonnet-4.5",
+	max_files: 100,
+	timeout: 120,
+	concurrency: 5,
+	language: "auto",
+};

package/src/types/diff.ts

@@ -0,0 +1,36 @@
+import type { FileStatus } from "./output.ts";
+
+export interface DiffHunk {
+	old_start: number;
+	old_count: number;
+	new_start: number;
+	new_count: number;
+	content: string;
+}
+
+export interface FileDiff {
+	path: string;
+	old_path: string | null;
+	status: FileStatus;
+	additions: number;
+	deletions: number;
+	is_binary: boolean;
+	hunks: DiffHunk[];
+	raw: string;
+}
+
+export interface ParsedDiff {
+	files: FileDiff[];
+	total_additions: number;
+	total_deletions: number;
+}
+
+export interface DiffChunk {
+	file_path: string;
+	status: FileStatus;
+	additions: number;
+	deletions: number;
+	is_binary: boolean;
+	diff_content: string;
+	estimated_tokens: number;
+}

package/src/types/github.ts

@@ -0,0 +1,28 @@
+export interface PrIdentifier {
+	owner: string;
+	repo: string;
+	number: number;
+}
+
+export interface PrCommit {
+	sha: string;
+	message: string;
+	author: string;
+	date: string;
+	files: string[];
+}
+
+export interface GithubPrData {
+	number: number;
+	title: string;
+	url: string;
+	base_branch: string;
+	head_branch: string;
+	author: string;
+	author_avatar?: string;
+	author_url?: string;
+	additions: number;
+	deletions: number;
+	changed_files: number;
+	commits: PrCommit[];
+}