lazyreview 0.1.4

package/dist/cli.js

@@ -0,0 +1,3830 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { render } from "ink";
+
+// src/app.tsx
+import React16, { useState as useState16, useCallback as useCallback6 } from "react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { Box as Box26, useApp, useInput as useInput13, useStdout as useStdout8 } from "ink";
+
+// src/theme/index.ts
+import React, { createContext, useContext } from "react";
+
+// src/theme/themes.ts
+var tokyoNight = {
+  name: "tokyo-night",
+  colors: {
+    bg: "#1a1b26",
+    text: "#c0caf5",
+    accent: "#7aa2f7",
+    muted: "#565f89",
+    border: "#3b4261",
+    primary: "#7aa2f7",
+    secondary: "#bb9af7",
+    success: "#9ece6a",
+    error: "#f7768e",
+    warning: "#e0af68",
+    info: "#7dcfff",
+    diffAdd: "#9ece6a",
+    diffDel: "#f7768e",
+    selection: "#283457",
+    listSelectedFg: "#c0caf5",
+    listSelectedBg: "#283457"
+  }
+};
+var dracula = {
+  name: "dracula",
+  colors: {
+    bg: "#282a36",
+    text: "#f8f8f2",
+    accent: "#bd93f9",
+    muted: "#6272a4",
+    border: "#44475a",
+    primary: "#bd93f9",
+    secondary: "#ff79c6",
+    success: "#50fa7b",
+    error: "#ff5555",
+    warning: "#f1fa8c",
+    info: "#8be9fd",
+    diffAdd: "#50fa7b",
+    diffDel: "#ff5555",
+    selection: "#44475a",
+    listSelectedFg: "#f8f8f2",
+    listSelectedBg: "#44475a"
+  }
+};
+var catppuccinMocha = {
+  name: "catppuccin-mocha",
+  colors: {
+    bg: "#1e1e2e",
+    text: "#cdd6f4",
+    accent: "#89b4fa",
+    muted: "#6c7086",
+    border: "#313244",
+    primary: "#89b4fa",
+    secondary: "#cba6f7",
+    success: "#a6e3a1",
+    error: "#f38ba8",
+    warning: "#f9e2af",
+    info: "#89dceb",
+    diffAdd: "#a6e3a1",
+    diffDel: "#f38ba8",
+    selection: "#313244",
+    listSelectedFg: "#cdd6f4",
+    listSelectedBg: "#313244"
+  }
+};
+var themes = {
+  "tokyo-night": tokyoNight,
+  dracula,
+  "catppuccin-mocha": catppuccinMocha
+};
+var defaultTheme = tokyoNight;
+
+// src/theme/index.ts
+var ThemeContext = createContext(defaultTheme);
+function ThemeProvider({
+  theme = defaultTheme,
+  children
+}) {
+  return React.createElement(ThemeContext.Provider, { value: theme }, children);
+}
+function useTheme() {
+  return useContext(ThemeContext);
+}
+function getThemeByName(name) {
+  return themes[name] ?? defaultTheme;
+}
+
+// src/components/layout/TopBar.tsx
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function TopBar({
+  username,
+  provider,
+  repoPath
+}) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      height: 1,
+      width: "100%",
+      justifyContent: "space-between",
+      paddingX: 1,
+      marginTop: 0.6,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+          /* @__PURE__ */ jsx(Text, { color: theme.colors.accent, bold: true, children: "LazyReview" }),
+          repoPath && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, children: "\u2502" }),
+            /* @__PURE__ */ jsx(Text, { color: theme.colors.text, children: repoPath })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+          /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, children: provider }),
+          /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, children: "\u2502" }),
+          /* @__PURE__ */ jsx(Text, { color: theme.colors.secondary, children: username })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/layout/Sidebar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var SIDEBAR_ITEMS = [
+  "Involved",
+  "My PRs",
+  "For Review",
+  "This Repo",
+  "Settings"
+];
+var sidebarIcons = {
+  Involved: "\u25C6",
+  "My PRs": "\u25CF",
+  "For Review": "\u25CE",
+  "This Repo": "\u25C8",
+  Settings: "\u2699"
+};
+function Sidebar({
+  selectedIndex,
+  visible,
+  isActive
+}) {
+  const theme = useTheme();
+  if (!visible) return null;
+  return /* @__PURE__ */ jsxs2(
+    Box2,
+    {
+      flexDirection: "column",
+      width: 24,
+      borderStyle: "single",
+      borderColor: isActive ? theme.colors.accent : theme.colors.border,
+      children: [
+        /* @__PURE__ */ jsx2(Box2, { paddingX: 1, paddingY: 0, children: /* @__PURE__ */ jsx2(Text2, { color: theme.colors.accent, bold: isActive, dimColor: !isActive, children: "Navigation" }) }),
+        /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingTop: 1, children: SIDEBAR_ITEMS.map((label, index) => {
+          const isSelected = index === selectedIndex;
+          const icon = sidebarIcons[label];
+          return /* @__PURE__ */ jsx2(Box2, { paddingX: 1, children: /* @__PURE__ */ jsxs2(
+            Text2,
+            {
+              color: isSelected ? theme.colors.accent : theme.colors.text,
+              backgroundColor: isSelected ? theme.colors.selection : void 0,
+              bold: isSelected,
+              dimColor: !isActive && !isSelected,
+              children: [
+                isSelected ? "\u25B8 " : "  ",
+                icon,
+                " ",
+                label
+              ]
+            }
+          ) }, label);
+        }) })
+      ]
+    }
+  );
+}
+
+// src/components/layout/MainPanel.tsx
+import { Box as Box3 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function MainPanel({
+  children,
+  isActive = false
+}) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsx3(
+    Box3,
+    {
+      flexDirection: "column",
+      flexGrow: 1,
+      borderStyle: "single",
+      borderColor: isActive ? theme.colors.accent : theme.colors.border,
+      children
+    }
+  );
+}
+
+// src/components/layout/StatusBar.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+
+// src/components/common/Spinner.tsx
+import { useState, useEffect } from "react";
+import { Text as Text3 } from "ink";
+import { jsxs as jsxs3 } from "react/jsx-runtime";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Spinner({ label }) {
+  const theme = useTheme();
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
+    }, 80);
+    return () => clearInterval(timer);
+  }, []);
+  return /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.accent, children: [
+    SPINNER_FRAMES[frame],
+    " ",
+    label
+  ] });
+}
+
+// src/hooks/useLoading.ts
+import { useSyncExternalStore } from "react";
+var loadingService = null;
+var emptyState = { isLoading: false, message: null };
+function useLoading() {
+  return useSyncExternalStore(
+    (callback) => {
+      if (!loadingService) return () => {
+      };
+      return loadingService.subscribe(callback);
+    },
+    () => loadingService?.getState() ?? emptyState,
+    () => emptyState
+  );
+}
+
+// src/components/layout/StatusBar.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var PANEL_HINTS = {
+  sidebar: "j/k:nav  gg/G:top/bottom  Enter:select  Tab:list  b:toggle  ?:help  q:quit",
+  list: "j/k:nav  gg/G:top/bottom  Enter:detail  Esc:sidebar  Tab:next  ?:help  q:quit",
+  detail: "j/k:scroll  Tab:tabs  Esc:list  ?:help  q:quit"
+};
+function StatusBar({ activePanel = "sidebar" }) {
+  const theme = useTheme();
+  const loadingState = useLoading();
+  const hints = PANEL_HINTS[activePanel];
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      height: 1,
+      width: "100%",
+      justifyContent: "space-between",
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsx4(Box4, { children: loadingState.isLoading ? /* @__PURE__ */ jsx4(Spinner, { label: loadingState.message ?? "Loading..." }) : /* @__PURE__ */ jsx4(Text4, { color: theme.colors.success, children: "Ready" }) }),
+        /* @__PURE__ */ jsx4(Box4, { gap: 1, children: /* @__PURE__ */ jsx4(Text4, { color: theme.colors.muted, children: hints }) })
+      ]
+    }
+  );
+}
+
+// src/components/layout/HelpModal.tsx
+import { Box as Box7, Text as Text6 } from "ink";
+
+// src/components/common/Divider.tsx
+import { Box as Box5, Text as Text5, useStdout } from "ink";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var DEFAULT_LINE_LENGTH = 36;
+function Divider({ title }) {
+  const theme = useTheme();
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  const len = Math.min(DEFAULT_LINE_LENGTH, Math.max(10, cols - 8));
+  const line = "\u2500".repeat(len);
+  if (title) {
+    const pad = Math.max(0, len - title.length - 2);
+    const left = Math.floor(pad / 2);
+    const right = pad - left;
+    const text = "\u2500".repeat(left) + ` ${title} ` + "\u2500".repeat(right);
+    return /* @__PURE__ */ jsx5(Box5, { paddingY: 0, children: /* @__PURE__ */ jsx5(Text5, { color: theme.colors.border, children: text }) });
+  }
+  return /* @__PURE__ */ jsx5(Box5, { paddingY: 0, children: /* @__PURE__ */ jsx5(Text5, { color: theme.colors.border, children: line }) });
+}
+
+// src/components/common/Modal.tsx
+import { Box as Box6, useStdout as useStdout2 } from "ink";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function Modal({ children }) {
+  const { stdout } = useStdout2();
+  const width = stdout?.columns ?? 80;
+  const height = stdout?.rows ?? 24;
+  return /* @__PURE__ */ jsx6(
+    Box6,
+    {
+      position: "absolute",
+      width,
+      height,
+      justifyContent: "center",
+      alignItems: "center",
+      children
+    }
+  );
+}
+
+// src/components/layout/HelpModal.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var shortcuts = [
+  { key: "j / k", description: "Move down / up" },
+  { key: "Enter", description: "Select / Open" },
+  { key: "Tab", description: "Switch focus panel" },
+  { key: "b", description: "Toggle sidebar" },
+  { key: "/", description: "Search / Filter PRs" },
+  { key: "s", description: "Sort PRs" },
+  { key: "n / p", description: "Next / Previous page" },
+  { key: "1 / 2 / 3", description: "Switch PR detail tabs" },
+  { key: "q", description: "Back / Quit" },
+  { key: "?", description: "Toggle this help" },
+  { key: "Ctrl+c", description: "Force quit" }
+];
+function HelpModal({ onClose }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsx7(Modal, { children: /* @__PURE__ */ jsxs5(
+    Box7,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.colors.accent,
+      backgroundColor: theme.colors.bg,
+      paddingX: 2,
+      paddingY: 1,
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx7(Text6, { color: theme.colors.accent, bold: true, children: "Keyboard Shortcuts" }),
+        /* @__PURE__ */ jsx7(Divider, {}),
+        /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: shortcuts.map((s) => /* @__PURE__ */ jsxs5(Box7, { gap: 2, children: [
+          /* @__PURE__ */ jsx7(Box7, { width: 16, children: /* @__PURE__ */ jsx7(Text6, { color: theme.colors.warning, children: s.key }) }),
+          /* @__PURE__ */ jsx7(Text6, { color: theme.colors.text, children: s.description })
+        ] }, s.key)) }),
+        /* @__PURE__ */ jsx7(Divider, {}),
+        /* @__PURE__ */ jsx7(Text6, { color: theme.colors.muted, dimColor: true, children: "Press ? to close" })
+      ]
+    }
+  ) });
+}
+
+// src/components/layout/TokenInputModal.tsx
+import { useState as useState3, useEffect as useEffect2 } from "react";
+import { Box as Box8, Text as Text7, useInput } from "ink";
+import { TextInput } from "@inkjs/ui";
+
+// src/hooks/useInputFocus.tsx
+import React3, { createContext as createContext2, useContext as useContext2, useState as useState2, useCallback } from "react";
+var InputFocusContext = createContext2({
+  isInputActive: false,
+  setInputActive: () => {
+  }
+});
+function InputFocusProvider({
+  children
+}) {
+  const [isInputActive, setIsInputActive] = useState2(false);
+  const setInputActive = useCallback((active) => {
+    setIsInputActive(active);
+  }, []);
+  return React3.createElement(
+    InputFocusContext.Provider,
+    { value: { isInputActive, setInputActive } },
+    children
+  );
+}
+function useInputFocus() {
+  return useContext2(InputFocusContext);
+}
+
+// src/components/layout/TokenInputModal.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function TokenInputModal({
+  onSubmit,
+  error
+}) {
+  const theme = useTheme();
+  const { setInputActive } = useInputFocus();
+  const [value, setValue] = useState3("");
+  useEffect2(() => {
+    setInputActive(true);
+    return () => setInputActive(false);
+  }, [setInputActive]);
+  const handleSubmit = () => {
+    const trimmed = value.trim();
+    if (trimmed) {
+      onSubmit(trimmed);
+    }
+  };
+  useInput((_input, key) => {
+    if (key.return) {
+      handleSubmit();
+    }
+  });
+  return /* @__PURE__ */ jsx8(Modal, { children: /* @__PURE__ */ jsxs6(
+    Box8,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.colors.accent,
+      backgroundColor: theme.colors.bg,
+      paddingX: 2,
+      paddingY: 1,
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx8(Text7, { color: theme.colors.accent, bold: true, children: "GitHub Token Required" }),
+        /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx8(Text7, { color: theme.colors.text, children: "No GitHub token found in your environment." }),
+          /* @__PURE__ */ jsx8(Text7, { color: theme.colors.muted, children: "Please enter your GitHub Personal Access Token:" })
+        ] }),
+        error && /* @__PURE__ */ jsxs6(Text7, { color: theme.colors.error, children: [
+          "Error: ",
+          error
+        ] }),
+        /* @__PURE__ */ jsx8(
+          Box8,
+          {
+            borderStyle: "single",
+            borderColor: theme.colors.border,
+            paddingX: 1,
+            width: 50,
+            children: /* @__PURE__ */ jsx8(TextInput, { defaultValue: value, onChange: setValue })
+          }
+        ),
+        /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx8(Text7, { color: theme.colors.muted, dimColor: true, children: "The token will be saved to ~/.config/lazyreview/.token" }),
+          /* @__PURE__ */ jsx8(Text7, { color: theme.colors.muted, dimColor: true, children: "Press Enter to submit, Ctrl+C to quit." })
+        ] }),
+        /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsx8(Text7, { color: theme.colors.info, children: "Get a token at: github.com/settings/tokens" }),
+          /* @__PURE__ */ jsx8(Text7, { color: theme.colors.muted, children: "Required scopes: repo, read:user" })
+        ] })
+      ]
+    }
+  ) });
+}
+
+// src/screens/PRDetailScreen.tsx
+import { useState as useState6 } from "react";
+import { Box as Box16, useInput as useInput4, useStdout as useStdout7 } from "ink";
+import { Match as Match2 } from "effect";
+
+// src/hooks/useGitHub.ts
+import { useQuery } from "@tanstack/react-query";
+import { Effect as Effect4 } from "effect";
+
+// src/services/GitHubApi.ts
+import { Context as Context2, Effect as Effect2, Layer as Layer2, Schema as S8 } from "effect";
+
+// src/models/errors.ts
+import { Data } from "effect";
+var GitHubError = class extends Data.TaggedError("GitHubError") {
+};
+var AuthError = class extends Data.TaggedError("AuthError") {
+};
+var ConfigError = class extends Data.TaggedError("ConfigError") {
+};
+var NetworkError = class extends Data.TaggedError("NetworkError") {
+};
+
+// src/models/pull-request.ts
+import { Schema as S2 } from "effect";
+
+// src/models/user.ts
+import { Schema as S } from "effect";
+var User = class extends S.Class("User")({
+  login: S.String,
+  id: S.Number,
+  avatar_url: S.String,
+  html_url: S.String,
+  type: S.optionalWith(S.String, { default: () => "User" })
+}) {
+};
+
+// src/models/pull-request.ts
+var Label = class extends S2.Class("Label")({
+  id: S2.Number,
+  name: S2.String,
+  color: S2.String,
+  description: S2.optionalWith(S2.NullOr(S2.String), { default: () => null })
+}) {
+};
+var BranchRef = class extends S2.Class("BranchRef")({
+  ref: S2.optionalWith(S2.String, { default: () => "" }),
+  sha: S2.optionalWith(S2.String, { default: () => "" }),
+  label: S2.optional(S2.String)
+}) {
+};
+var PullRequest = class extends S2.Class("PullRequest")({
+  id: S2.Number,
+  number: S2.Number,
+  title: S2.String,
+  body: S2.optionalWith(S2.NullOr(S2.String), { default: () => null }),
+  state: S2.Literal("open", "closed"),
+  draft: S2.optionalWith(S2.Boolean, { default: () => false }),
+  merged: S2.optionalWith(S2.Boolean, { default: () => false }),
+  user: User,
+  labels: S2.optionalWith(S2.Array(Label), { default: () => [] }),
+  created_at: S2.String,
+  updated_at: S2.String,
+  merged_at: S2.optionalWith(S2.NullOr(S2.String), { default: () => null }),
+  closed_at: S2.optionalWith(S2.NullOr(S2.String), { default: () => null }),
+  html_url: S2.String,
+  head: S2.optionalWith(BranchRef, { default: () => new BranchRef({ ref: "", sha: "" }) }),
+  base: S2.optionalWith(BranchRef, { default: () => new BranchRef({ ref: "", sha: "" }) }),
+  additions: S2.optionalWith(S2.Number, { default: () => 0 }),
+  deletions: S2.optionalWith(S2.Number, { default: () => 0 }),
+  changed_files: S2.optionalWith(S2.Number, { default: () => 0 }),
+  comments: S2.optionalWith(S2.Number, { default: () => 0 }),
+  review_comments: S2.optionalWith(S2.Number, { default: () => 0 }),
+  requested_reviewers: S2.optionalWith(S2.Array(User), { default: () => [] })
+}) {
+};
+
+// src/models/comment.ts
+import { Schema as S3 } from "effect";
+var Comment = class extends S3.Class("Comment")({
+  id: S3.Number,
+  body: S3.String,
+  user: User,
+  created_at: S3.String,
+  updated_at: S3.String,
+  html_url: S3.String,
+  path: S3.optional(S3.String),
+  line: S3.optional(S3.NullOr(S3.Number)),
+  side: S3.optional(S3.Literal("LEFT", "RIGHT")),
+  in_reply_to_id: S3.optional(S3.Number)
+}) {
+};
+
+// src/models/review.ts
+import { Schema as S4 } from "effect";
+var Review = class extends S4.Class("Review")({
+  id: S4.Number,
+  user: User,
+  body: S4.optionalWith(S4.NullOr(S4.String), { default: () => null }),
+  state: S4.Literal(
+    "APPROVED",
+    "CHANGES_REQUESTED",
+    "COMMENTED",
+    "DISMISSED",
+    "PENDING"
+  ),
+  submitted_at: S4.optionalWith(S4.NullOr(S4.String), { default: () => null }),
+  html_url: S4.String
+}) {
+};
+
+// src/models/file-change.ts
+import { Schema as S5 } from "effect";
+var FileChange = class extends S5.Class("FileChange")({
+  sha: S5.String,
+  filename: S5.String,
+  status: S5.Literal(
+    "added",
+    "removed",
+    "modified",
+    "renamed",
+    "copied",
+    "changed",
+    "unchanged"
+  ),
+  additions: S5.Number,
+  deletions: S5.Number,
+  changes: S5.Number,
+  patch: S5.optional(S5.String),
+  previous_filename: S5.optional(S5.String),
+  blob_url: S5.optional(S5.String),
+  raw_url: S5.optional(S5.String)
+}) {
+};
+
+// src/models/commit.ts
+import { Schema as S6 } from "effect";
+var CommitAuthor = class extends S6.Class("CommitAuthor")({
+  name: S6.String,
+  email: S6.String,
+  date: S6.String
+}) {
+};
+var CommitDetails = class extends S6.Class("CommitDetails")({
+  message: S6.String,
+  author: CommitAuthor
+}) {
+};
+var Commit = class extends S6.Class("Commit")({
+  sha: S6.String,
+  commit: CommitDetails,
+  author: S6.optionalWith(S6.NullOr(User), { default: () => null }),
+  html_url: S6.String
+}) {
+};
+
+// src/services/Auth.ts
+import { Context, Effect, Layer, Schema as S7 } from "effect";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { writeFile, readFile, mkdir, unlink } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var execFileAsync = promisify(execFile);
+var CONFIG_DIR = join(homedir(), ".config", "lazyreview");
+var TOKEN_FILE = join(CONFIG_DIR, ".token");
+var sessionToken = null;
+var preferredSource = null;
+async function loadSavedToken() {
+  try {
+    const token = await readFile(TOKEN_FILE, "utf-8");
+    return token.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function saveTokenToFile(token) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(TOKEN_FILE, token, { mode: 384 });
+}
+async function deleteSavedToken() {
+  try {
+    await unlink(TOKEN_FILE);
+  } catch {
+  }
+}
+var savedToken = null;
+loadSavedToken().then((token) => {
+  savedToken = token;
+});
+function maskToken(token) {
+  if (token.length <= 8) return "****";
+  return `${token.slice(0, 4)}...${token.slice(-4)}`;
+}
+async function tryGetGhToken() {
+  try {
+    const { stdout } = await execFileAsync("gh", ["auth", "token"]);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+var Auth = class extends Context.Tag("Auth")() {
+};
+function resolveToken() {
+  return Effect.gen(function* () {
+    if (preferredSource === "manual") {
+      const manualToken2 = sessionToken ?? savedToken;
+      if (manualToken2) return manualToken2;
+      return yield* Effect.fail(
+        new AuthError({ message: "No manual token found", reason: "no_token" })
+      );
+    }
+    if (preferredSource === "env") {
+      const envToken2 = process.env["LAZYREVIEW_GITHUB_TOKEN"];
+      if (envToken2) return envToken2;
+      return yield* Effect.fail(
+        new AuthError({ message: "LAZYREVIEW_GITHUB_TOKEN not set", reason: "no_token" })
+      );
+    }
+    if (preferredSource === "gh_cli") {
+      const ghToken = yield* Effect.tryPromise({
+        try: tryGetGhToken,
+        catch: () => new AuthError({ message: "gh CLI failed", reason: "no_token" })
+      });
+      if (ghToken) return ghToken;
+      return yield* Effect.fail(
+        new AuthError({ message: "gh CLI token not available", reason: "no_token" })
+      );
+    }
+    const envToken = process.env["LAZYREVIEW_GITHUB_TOKEN"];
+    if (envToken) return envToken;
+    const manualToken = sessionToken ?? savedToken;
+    if (manualToken) return manualToken;
+    const ghResult = yield* Effect.tryPromise({
+      try: tryGetGhToken,
+      catch: () => new AuthError({
+        message: "No GitHub token found. Set LAZYREVIEW_GITHUB_TOKEN or configure in Settings.",
+        reason: "no_token"
+      })
+    });
+    if (ghResult) return ghResult;
+    return yield* Effect.fail(
+      new AuthError({
+        message: "No GitHub token found. Set LAZYREVIEW_GITHUB_TOKEN or configure in Settings.",
+        reason: "no_token"
+      })
+    );
+  });
+}
+function resolveTokenInfo() {
+  return Effect.gen(function* () {
+    if (preferredSource === "manual") {
+      const manualToken2 = sessionToken ?? savedToken;
+      if (manualToken2) {
+        return {
+          source: "manual",
+          token: manualToken2,
+          maskedToken: maskToken(manualToken2)
+        };
+      }
+    }
+    if (preferredSource === "env") {
+      const envToken2 = process.env["LAZYREVIEW_GITHUB_TOKEN"];
+      if (envToken2) {
+        return {
+          source: "env",
+          token: envToken2,
+          maskedToken: maskToken(envToken2)
+        };
+      }
+    }
+    if (preferredSource === "gh_cli") {
+      const ghToken2 = yield* Effect.promise(tryGetGhToken);
+      if (ghToken2) {
+        return {
+          source: "gh_cli",
+          token: ghToken2,
+          maskedToken: maskToken(ghToken2)
+        };
+      }
+    }
+    const envToken = process.env["LAZYREVIEW_GITHUB_TOKEN"];
+    if (envToken) {
+      return {
+        source: "env",
+        token: envToken,
+        maskedToken: maskToken(envToken)
+      };
+    }
+    const manualToken = sessionToken ?? savedToken;
+    if (manualToken) {
+      return {
+        source: "manual",
+        token: manualToken,
+        maskedToken: maskToken(manualToken)
+      };
+    }
+    const ghToken = yield* Effect.promise(tryGetGhToken);
+    if (ghToken) {
+      return {
+        source: "gh_cli",
+        token: ghToken,
+        maskedToken: maskToken(ghToken)
+      };
+    }
+    return {
+      source: "none",
+      token: null,
+      maskedToken: null
+    };
+  });
+}
+var AuthLive = Layer.succeed(
+  Auth,
+  Auth.of({
+    getToken: resolveToken,
+    getUser: () => Effect.gen(function* () {
+      const token = yield* resolveToken();
+      const user = yield* Effect.tryPromise({
+        try: async () => {
+          const response = await fetch("https://api.github.com/user", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+              Accept: "application/vnd.github+json"
+            }
+          });
+          if (!response.ok) {
+            throw new Error(`GitHub API returned ${response.status}`);
+          }
+          const data = await response.json();
+          return S7.decodeUnknownSync(User)(data);
+        },
+        catch: (error) => new AuthError({
+          message: `Failed to get user: ${String(error)}`,
+          reason: "invalid_token"
+        })
+      });
+      return user;
+    }),
+    isAuthenticated: () => Effect.gen(function* () {
+      const result = yield* Effect.either(resolveToken());
+      return result._tag === "Right";
+    }),
+    setToken: (token) => Effect.gen(function* () {
+      sessionToken = token;
+      savedToken = token;
+      preferredSource = "manual";
+      yield* Effect.promise(() => saveTokenToFile(token));
+    }),
+    getTokenInfo: resolveTokenInfo,
+    setPreferredSource: (source) => Effect.sync(() => {
+      preferredSource = source === "none" ? null : source;
+    }),
+    getAvailableSources: () => Effect.gen(function* () {
+      const sources = [];
+      const envToken = process.env["LAZYREVIEW_GITHUB_TOKEN"];
+      if (envToken) {
+        sources.push("env");
+      }
+      if (sessionToken || savedToken) {
+        sources.push("manual");
+      }
+      const ghToken = yield* Effect.promise(tryGetGhToken);
+      if (ghToken) {
+        sources.push("gh_cli");
+      }
+      return sources;
+    }),
+    clearManualToken: () => Effect.gen(function* () {
+      sessionToken = null;
+      savedToken = null;
+      if (preferredSource === "manual") {
+        preferredSource = null;
+      }
+      yield* Effect.promise(deleteSavedToken);
+    })
+  })
+);
+
+// src/services/GitHubApi.ts
+var BASE_URL = "https://api.github.com";
+var GitHubApi = class extends Context2.Tag("GitHubApi")() {
+};
+function fetchGitHub(path, token, schema) {
+  const url = `${BASE_URL}${path}`;
+  const decode = S8.decodeUnknownSync(schema);
+  return Effect2.tryPromise({
+    try: async () => {
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28"
+        }
+      });
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new GitHubError({
+          message: `GitHub API error: ${response.status} ${response.statusText} - ${body}`,
+          status: response.status,
+          url
+        });
+      }
+      const data = await response.json();
+      return decode(data);
+    },
+    catch: (error) => {
+      if (error instanceof GitHubError) return error;
+      return new NetworkError({
+        message: `Network request failed: ${String(error)}`,
+        cause: error
+      });
+    }
+  });
+}
+var SearchResultSchema = S8.Struct({
+  total_count: S8.Number,
+  incomplete_results: S8.Boolean,
+  items: S8.Array(PullRequest)
+});
+function fetchGitHubSearch(query, token) {
+  const url = `${BASE_URL}/search/issues?q=${encodeURIComponent(query)}&per_page=100`;
+  const decode = S8.decodeUnknownSync(SearchResultSchema);
+  return Effect2.tryPromise({
+    try: async () => {
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28"
+        }
+      });
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new GitHubError({
+          message: `GitHub API error: ${response.status} ${response.statusText} - ${body}`,
+          status: response.status,
+          url
+        });
+      }
+      const data = await response.json();
+      const result = decode(data);
+      return result.items;
+    },
+    catch: (error) => {
+      if (error instanceof GitHubError) return error;
+      return new NetworkError({
+        message: `Network request failed: ${String(error)}`,
+        cause: error
+      });
+    }
+  });
+}
+function buildQueryString(options) {
+  const params = new URLSearchParams();
+  if (options.state) params.set("state", options.state);
+  if (options.sort) params.set("sort", options.sort);
+  if (options.direction) params.set("direction", options.direction);
+  if (options.perPage) params.set("per_page", String(options.perPage));
+  if (options.page) params.set("page", String(options.page));
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
+var GitHubApiLive = Layer2.effect(
+  GitHubApi,
+  Effect2.gen(function* () {
+    const auth = yield* Auth;
+    return GitHubApi.of({
+      listPullRequests: (owner, repo, options = {}) => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        const mergedOptions = { ...options, perPage: options.perPage ?? 100 };
+        const qs = buildQueryString(mergedOptions);
+        return yield* fetchGitHub(
+          `/repos/${owner}/${repo}/pulls${qs}`,
+          token,
+          S8.Array(PullRequest)
+        );
+      }),
+      getPullRequest: (owner, repo, number) => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        return yield* fetchGitHub(
+          `/repos/${owner}/${repo}/pulls/${number}`,
+          token,
+          PullRequest
+        );
+      }),
+      getPullRequestFiles: (owner, repo, number) => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        return yield* fetchGitHub(
+          `/repos/${owner}/${repo}/pulls/${number}/files`,
+          token,
+          S8.Array(FileChange)
+        );
+      }),
+      getPullRequestComments: (owner, repo, number) => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        return yield* fetchGitHub(
+          `/repos/${owner}/${repo}/pulls/${number}/comments`,
+          token,
+          S8.Array(Comment)
+        );
+      }),
+      getPullRequestReviews: (owner, repo, number) => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        return yield* fetchGitHub(
+          `/repos/${owner}/${repo}/pulls/${number}/reviews`,
+          token,
+          S8.Array(Review)
+        );
+      }),
+      getPullRequestCommits: (owner, repo, number) => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        return yield* fetchGitHub(
+          `/repos/${owner}/${repo}/pulls/${number}/commits`,
+          token,
+          S8.Array(Commit)
+        );
+      }),
+      getMyPRs: () => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        return yield* fetchGitHubSearch("is:pr is:open author:@me", token);
+      }),
+      getReviewRequests: () => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        return yield* fetchGitHubSearch(
+          "is:pr is:open review-requested:@me",
+          token
+        );
+      }),
+      getInvolvedPRs: () => Effect2.gen(function* () {
+        const token = yield* auth.getToken();
+        return yield* fetchGitHubSearch("is:pr is:open involves:@me", token);
+      })
+    });
+  })
+);
+
+// src/services/index.ts
+import { Layer as Layer5 } from "effect";
+
+// src/services/Config.ts
+import { Context as Context3, Effect as Effect3, Layer as Layer3, Schema as S9 } from "effect";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname } from "path";
+import { parse, stringify } from "yaml";
+var KeybindingsSchema = S9.Struct({
+  toggleSidebar: S9.optionalWith(S9.String, { default: () => "b" }),
+  help: S9.optionalWith(S9.String, { default: () => "?" }),
+  quit: S9.optionalWith(S9.String, { default: () => "q" })
+});
+var AppConfig = class extends S9.Class("AppConfig")({
+  provider: S9.optionalWith(S9.Literal("github"), {
+    default: () => "github"
+  }),
+  theme: S9.optionalWith(S9.String, { default: () => "tokyo-night" }),
+  defaultOwner: S9.optional(S9.String),
+  defaultRepo: S9.optional(S9.String),
+  pageSize: S9.optionalWith(S9.Number.pipe(S9.int(), S9.between(1, 100)), {
+    default: () => 30
+  }),
+  keybindings: S9.optionalWith(KeybindingsSchema, {
+    default: () => ({ toggleSidebar: "b", help: "?", quit: "q" })
+  })
+}) {
+};
+var defaultConfig = S9.decodeUnknownSync(AppConfig)({});
+var Config = class extends Context3.Tag("Config")() {
+};
+function getConfigPath() {
+  return join2(homedir2(), ".config", "lazyreview", "config.yaml");
+}
+var ConfigLive = Layer3.succeed(
+  Config,
+  Config.of({
+    getPath: getConfigPath,
+    load: () => Effect3.tryPromise({
+      try: async () => {
+        const configPath = getConfigPath();
+        try {
+          const content = await readFile2(configPath, "utf-8");
+          const parsed = parse(content);
+          return S9.decodeUnknownSync(AppConfig)(parsed);
+        } catch {
+          return defaultConfig;
+        }
+      },
+      catch: (error) => new ConfigError({
+        message: `Failed to load config: ${String(error)}`,
+        path: getConfigPath()
+      })
+    }),
+    save: (config) => Effect3.tryPromise({
+      try: async () => {
+        const configPath = getConfigPath();
+        await mkdir2(dirname(configPath), { recursive: true });
+        await writeFile2(configPath, stringify(config), "utf-8");
+      },
+      catch: (error) => new ConfigError({
+        message: `Failed to save config: ${String(error)}`,
+        path: getConfigPath()
+      })
+    })
+  })
+);
+
+// src/services/Loading.ts
+import { Context as Context4, Layer as Layer4 } from "effect";
+var Loading = class extends Context4.Tag("Loading")() {
+};
+function createLoadingService() {
+  let state = { isLoading: false, message: null };
+  const listeners = /* @__PURE__ */ new Set();
+  function notify() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  return {
+    start: (message) => {
+      state = { isLoading: true, message };
+      notify();
+    },
+    stop: () => {
+      state = { isLoading: false, message: null };
+      notify();
+    },
+    getState: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+var LoadingLive = Layer4.sync(Loading, createLoadingService);
+
+// src/services/index.ts
+var GitHubApiFullLive = GitHubApiLive.pipe(Layer5.provide(AuthLive));
+var AppLayer = Layer5.mergeAll(
+  ConfigLive,
+  AuthLive,
+  LoadingLive,
+  GitHubApiFullLive
+);
+
+// src/hooks/useGitHub.ts
+function runEffect(effect) {
+  return Effect4.runPromise(
+    effect.pipe(Effect4.provide(AppLayer))
+  );
+}
+function usePullRequests(owner, repo, options) {
+  return useQuery({
+    queryKey: ["prs", owner, repo, options],
+    queryFn: () => runEffect(
+      Effect4.gen(function* () {
+        const api = yield* GitHubApi;
+        return yield* api.listPullRequests(owner, repo, options);
+      })
+    ),
+    enabled: !!owner && !!repo
+  });
+}
+function usePRFiles(owner, repo, number) {
+  return useQuery({
+    queryKey: ["pr-files", owner, repo, number],
+    queryFn: () => runEffect(
+      Effect4.gen(function* () {
+        const api = yield* GitHubApi;
+        return yield* api.getPullRequestFiles(owner, repo, number);
+      })
+    ),
+    enabled: !!owner && !!repo && !!number
+  });
+}
+function usePRComments(owner, repo, number) {
+  return useQuery({
+    queryKey: ["pr-comments", owner, repo, number],
+    queryFn: () => runEffect(
+      Effect4.gen(function* () {
+        const api = yield* GitHubApi;
+        return yield* api.getPullRequestComments(owner, repo, number);
+      })
+    ),
+    enabled: !!owner && !!repo && !!number
+  });
+}
+function usePRReviews(owner, repo, number) {
+  return useQuery({
+    queryKey: ["pr-reviews", owner, repo, number],
+    queryFn: () => runEffect(
+      Effect4.gen(function* () {
+        const api = yield* GitHubApi;
+        return yield* api.getPullRequestReviews(owner, repo, number);
+      })
+    ),
+    enabled: !!owner && !!repo && !!number
+  });
+}
+function usePRCommits(owner, repo, number) {
+  return useQuery({
+    queryKey: ["pr-commits", owner, repo, number],
+    queryFn: () => runEffect(
+      Effect4.gen(function* () {
+        const api = yield* GitHubApi;
+        return yield* api.getPullRequestCommits(owner, repo, number);
+      })
+    ),
+    enabled: !!owner && !!repo && !!number
+  });
+}
+function useMyPRs() {
+  return useQuery({
+    queryKey: ["my-prs"],
+    queryFn: () => runEffect(
+      Effect4.gen(function* () {
+        const api = yield* GitHubApi;
+        return yield* api.getMyPRs();
+      })
+    )
+  });
+}
+function useReviewRequests() {
+  return useQuery({
+    queryKey: ["review-requests"],
+    queryFn: () => runEffect(
+      Effect4.gen(function* () {
+        const api = yield* GitHubApi;
+        return yield* api.getReviewRequests();
+      })
+    )
+  });
+}
+function useInvolvedPRs() {
+  return useQuery({
+    queryKey: ["involved-prs"],
+    queryFn: () => runEffect(
+      Effect4.gen(function* () {
+        const api = yield* GitHubApi;
+        return yield* api.getInvolvedPRs();
+      })
+    )
+  });
+}
+
+// src/components/pr/PRHeader.tsx
+import { Box as Box9, Text as Text8 } from "ink";
+
+// src/utils/date.ts
+import { formatDistanceToNow, parseISO, format } from "date-fns";
+function timeAgo(dateString) {
+  try {
+    const date = parseISO(dateString);
+    return formatDistanceToNow(date, { addSuffix: true });
+  } catch {
+    return dateString;
+  }
+}
+
+// src/components/pr/PRHeader.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function PRHeader({ pr }) {
+  const theme = useTheme();
+  const stateColor = pr.draft ? theme.colors.muted : pr.state === "open" ? theme.colors.success : theme.colors.error;
+  const stateLabel = pr.draft ? "Draft" : pr.merged ? "Merged" : pr.state === "open" ? "Open" : "Closed";
+  return /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsxs7(Box9, { gap: 1, children: [
+      /* @__PURE__ */ jsxs7(Text8, { color: stateColor, bold: true, children: [
+        "[",
+        stateLabel,
+        "]"
+      ] }),
+      /* @__PURE__ */ jsxs7(Text8, { color: theme.colors.accent, bold: true, children: [
+        "#",
+        pr.number
+      ] }),
+      /* @__PURE__ */ jsx9(Text8, { color: theme.colors.text, bold: true, children: pr.title })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box9, { gap: 1, paddingLeft: 2, children: [
+      /* @__PURE__ */ jsx9(Text8, { color: theme.colors.secondary, children: pr.user.login }),
+      /* @__PURE__ */ jsx9(Text8, { color: theme.colors.muted, children: "wants to merge" }),
+      /* @__PURE__ */ jsx9(Text8, { color: theme.colors.info, children: pr.head.ref }),
+      /* @__PURE__ */ jsx9(Text8, { color: theme.colors.muted, children: "into" }),
+      /* @__PURE__ */ jsx9(Text8, { color: theme.colors.info, children: pr.base.ref })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box9, { gap: 2, paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs7(Text8, { color: theme.colors.muted, children: [
+        "opened ",
+        timeAgo(pr.created_at)
+      ] }),
+      /* @__PURE__ */ jsxs7(Text8, { color: theme.colors.diffAdd, children: [
+        "+",
+        pr.additions
+      ] }),
+      /* @__PURE__ */ jsxs7(Text8, { color: theme.colors.diffDel, children: [
+        "-",
+        pr.deletions
+      ] }),
+      /* @__PURE__ */ jsxs7(Text8, { color: theme.colors.muted, children: [
+        pr.changed_files,
+        " files changed"
+      ] })
+    ] }),
+    pr.labels.length > 0 && /* @__PURE__ */ jsx9(Box9, { gap: 1, paddingLeft: 2, children: pr.labels.map((label) => /* @__PURE__ */ jsxs7(Text8, { color: `#${label.color}`, children: [
+      "[",
+      label.name,
+      "]"
+    ] }, label.id)) })
+  ] });
+}
+
+// src/components/pr/PRTabs.tsx
+import { Box as Box10 } from "ink";
+import { Tab, Tabs } from "ink-tab";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var PR_TAB_NAMES = ["Conversations", "Commits", "Files"];
+function PRTabs({ activeIndex, onChange }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsx10(
+    Box10,
+    {
+      flexDirection: "row",
+      paddingX: 1,
+      paddingY: 1,
+      borderStyle: "single",
+      borderColor: theme.colors.border,
+      children: /* @__PURE__ */ jsx10(
+        Tabs,
+        {
+          defaultValue: PR_TAB_NAMES[activeIndex],
+          onChange: (name) => {
+            const index = PR_TAB_NAMES.indexOf(name);
+            if (index >= 0) onChange(index);
+          },
+          showIndex: true,
+          isFocused: true,
+          colors: {
+            activeTab: {
+              color: theme.colors.accent,
+              backgroundColor: theme.colors.bg
+            }
+          },
+          keyMap: { useNumbers: true, useTab: true },
+          children: PR_TAB_NAMES.map((name) => /* @__PURE__ */ jsx10(Tab, { name, children: name }, name))
+        },
+        activeIndex
+      )
+    }
+  );
+}
+
+// src/components/pr/FilesTab.tsx
+import React5, { useEffect as useEffect4, useMemo, useRef as useRef2, useState as useState5 } from "react";
+import { Box as Box12, Text as Text10, useInput as useInput3, useStdout as useStdout3 } from "ink";
+import { UnorderedList } from "@inkjs/ui";
+import { ScrollList } from "ink-scroll-list";
+import SyntaxHighlight from "ink-syntax-highlight";
+
+// src/hooks/useListNavigation.ts
+import { useInput as useInput2 } from "ink";
+import { useCallback as useCallback2, useEffect as useEffect3, useRef, useState as useState4 } from "react";
+function useListNavigation({
+  itemCount,
+  viewportHeight,
+  isActive = true
+}) {
+  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const gPressedAt = useRef(null);
+  const prevItemCount = useRef(itemCount);
+  useEffect3(() => {
+    const wasAtEnd = selectedIndex === prevItemCount.current - 1;
+    prevItemCount.current = itemCount;
+    if (wasAtEnd && itemCount > 0) {
+      setSelectedIndex(itemCount - 1);
+    }
+  }, [itemCount, selectedIndex]);
+  useEffect3(() => {
+    if (itemCount === 0) {
+      setSelectedIndex(0);
+    } else if (selectedIndex >= itemCount) {
+      setSelectedIndex(itemCount - 1);
+    }
+  }, [itemCount, selectedIndex]);
+  const clamp = useCallback2(
+    (index) => Math.max(0, Math.min(index, itemCount - 1)),
+    [itemCount]
+  );
+  useInput2(
+    (input, key) => {
+      if (!isActive || itemCount === 0) return;
+      if (input === "j" || key.downArrow) {
+        setSelectedIndex((i) => clamp(i + 1));
+        return;
+      }
+      if (input === "k" || key.upArrow) {
+        setSelectedIndex((i) => clamp(i - 1));
+        return;
+      }
+      if (input === "G") {
+        setSelectedIndex(itemCount - 1);
+        return;
+      }
+      if (input === "g") {
+        const now = Date.now();
+        if (gPressedAt.current !== null && now - gPressedAt.current < 500) {
+          setSelectedIndex(0);
+          gPressedAt.current = null;
+        } else {
+          gPressedAt.current = now;
+        }
+        return;
+      }
+      if (key.ctrl && input === "d") {
+        setSelectedIndex((i) => clamp(i + Math.floor(viewportHeight / 2)));
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        setSelectedIndex((i) => clamp(i - Math.floor(viewportHeight / 2)));
+        return;
+      }
+      gPressedAt.current = null;
+    },
+    { isActive }
+  );
+  const scrollOffset = deriveScrollOffset(
+    selectedIndex,
+    viewportHeight,
+    itemCount
+  );
+  return { selectedIndex, scrollOffset, setSelectedIndex };
+}
+function deriveScrollOffset(selectedIndex, viewportHeight, itemCount) {
+  if (itemCount <= viewportHeight) return 0;
+  let offset = selectedIndex - Math.floor(viewportHeight / 2);
+  offset = Math.max(0, offset);
+  offset = Math.min(offset, itemCount - viewportHeight);
+  return offset;
+}
+
+// src/models/diff.ts
+function parseDiffPatch(patch) {
+  const hunks = [];
+  const lines = patch.split("\n");
+  let currentHunk = null;
+  let currentLines = [];
+  let oldLine = 0;
+  let newLine = 0;
+  for (const line of lines) {
+    const hunkMatch = line.match(
+      /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/
+    );
+    if (hunkMatch) {
+      if (currentHunk) {
+        hunks.push({ ...currentHunk, lines: currentLines });
+      }
+      oldLine = parseInt(hunkMatch[1], 10);
+      newLine = parseInt(hunkMatch[3], 10);
+      currentLines = [{ type: "header", content: line }];
+      currentHunk = {
+        header: line,
+        oldStart: oldLine,
+        oldCount: parseInt(hunkMatch[2] ?? "1", 10),
+        newStart: newLine,
+        newCount: parseInt(hunkMatch[4] ?? "1", 10),
+        lines: []
+      };
+      continue;
+    }
+    if (!currentHunk) continue;
+    if (line.startsWith("+")) {
+      currentLines.push({
+        type: "add",
+        content: line.slice(1),
+        newLineNumber: newLine++
+      });
+    } else if (line.startsWith("-")) {
+      currentLines.push({
+        type: "del",
+        content: line.slice(1),
+        oldLineNumber: oldLine++
+      });
+    } else if (line.startsWith(" ") || line === "") {
+      currentLines.push({
+        type: "context",
+        content: line.slice(1),
+        oldLineNumber: oldLine++,
+        newLineNumber: newLine++
+      });
+    }
+  }
+  if (currentHunk) {
+    hunks.push({ ...currentHunk, lines: currentLines });
+  }
+  return hunks;
+}
+
+// src/components/common/EmptyState.tsx
+import { Box as Box11, Text as Text9 } from "ink";
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+function EmptyState({
+  icon = "~",
+  message,
+  hint
+}) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs8(
+    Box11,
+    {
+      flexDirection: "column",
+      alignItems: "center",
+      justifyContent: "center",
+      flexGrow: 1,
+      paddingY: 2,
+      children: [
+        /* @__PURE__ */ jsx11(Text9, { color: theme.colors.muted, children: icon }),
+        /* @__PURE__ */ jsx11(Text9, { color: theme.colors.muted, children: message }),
+        hint && /* @__PURE__ */ jsx11(Text9, { color: theme.colors.muted, dimColor: true, children: hint })
+      ]
+    }
+  );
+}
+
+// src/components/pr/FilesTab.tsx
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+function buildFileTree(files) {
+  const root = { dirs: {}, files: [] };
+  for (const file of files) {
+    const parts = file.filename.split("/");
+    let current = root;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const segment = parts[i];
+      if (!current.dirs[segment]) {
+        current.dirs[segment] = { dirs: {}, files: [] };
+      }
+      current = current.dirs[segment];
+    }
+    const leafName = parts[parts.length - 1] ?? file.filename;
+    current.files.push(file);
+  }
+  function toTree(node) {
+    const result = [];
+    const dirNames = Object.keys(node.dirs).sort((a, b) => a.localeCompare(b));
+    const files2 = [...node.files].sort(
+      (a, b) => a.filename.localeCompare(b.filename)
+    );
+    for (const name of dirNames) {
+      result.push({
+        type: "dir",
+        name,
+        children: toTree(node.dirs[name])
+      });
+    }
+    for (const file of files2) {
+      result.push({ type: "file", file });
+    }
+    return result;
+  }
+  return toTree(root);
+}
+function flattenTreeToFiles(nodes) {
+  const out = [];
+  function walk(n) {
+    for (const node of n) {
+      if (node.type === "file") out.push(node.file);
+      else walk(node.children);
+    }
+  }
+  walk(nodes);
+  return out;
+}
+function buildDisplayRows(nodes, indent = 0, fileIndexRef) {
+  const rows = [];
+  for (const node of nodes) {
+    if (node.type === "file") {
+      const parts = node.file.filename.split("/");
+      const name = parts[parts.length - 1] ?? node.file.filename;
+      rows.push({
+        indent,
+        type: "file",
+        name,
+        file: node.file,
+        fileIndex: fileIndexRef.current
+      });
+      fileIndexRef.current += 1;
+    } else {
+      rows.push({ indent, type: "dir", name: node.name });
+      rows.push(...buildDisplayRows(node.children, indent + 1, fileIndexRef));
+    }
+  }
+  return rows;
+}
+function getLanguageFromFilename(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  const map = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    json: "json",
+    md: "markdown",
+    py: "python",
+    go: "go",
+    rs: "rust",
+    css: "css",
+    scss: "scss",
+    html: "html",
+    yaml: "yaml",
+    yml: "yaml"
+  };
+  return ext ? map[ext] : void 0;
+}
+function FileItem({
+  item,
+  isFocus,
+  isSelected
+}) {
+  const theme = useTheme();
+  const statusColor = item.status === "added" ? theme.colors.diffAdd : item.status === "removed" ? theme.colors.diffDel : theme.colors.warning;
+  const statusIcon = item.status === "added" ? "A" : item.status === "removed" ? "D" : item.status === "renamed" ? "R" : "M";
+  const parts = item.filename.split("/");
+  const filename = parts[parts.length - 1] ?? item.filename;
+  return /* @__PURE__ */ jsxs9(Box12, { paddingX: 0, gap: 1, width: "100%", children: [
+    /* @__PURE__ */ jsx12(Text10, { color: statusColor, bold: true, children: statusIcon }),
+    /* @__PURE__ */ jsx12(
+      Text10,
+      {
+        color: isFocus ? theme.colors.listSelectedFg : isSelected ? theme.colors.accent : theme.colors.text,
+        bold: isFocus || isSelected,
+        inverse: isFocus,
+        children: filename
+      }
+    )
+  ] });
+}
+function DiffLineView({
+  line,
+  lineNumber,
+  isFocus,
+  language
+}) {
+  const theme = useTheme();
+  const bgColor = isFocus ? theme.colors.selection : void 0;
+  const textColor = line.type === "add" ? theme.colors.diffAdd : line.type === "del" ? theme.colors.diffDel : line.type === "header" ? theme.colors.info : theme.colors.text;
+  const prefix = line.type === "add" ? "+" : line.type === "del" ? "-" : line.type === "header" ? "" : " ";
+  const useSyntaxHighlight = line.type === "context" && language && line.content.trim().length > 0;
+  return (
+    // @ts-ignore
+    /* @__PURE__ */ jsxs9(Box12, { backgroundColor: bgColor, children: [
+      /* @__PURE__ */ jsx12(Box12, { width: 5, children: /* @__PURE__ */ jsx12(Text10, { color: theme.colors.muted, children: line.type === "header" ? "" : String(lineNumber).padStart(4, " ") }) }),
+      useSyntaxHighlight ? /* @__PURE__ */ jsxs9(Box12, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx12(Text10, { color: theme.colors.text, children: prefix }),
+        /* @__PURE__ */ jsx12(SyntaxHighlight, { code: line.content, language })
+      ] }) : /* @__PURE__ */ jsxs9(Text10, { color: textColor, bold: isFocus, inverse: isFocus, children: [
+        prefix,
+        line.content
+      ] })
+    ] })
+  );
+}
+function DiffView({
+  hunks,
+  selectedLine,
+  scrollOffset,
+  viewportHeight,
+  isActive,
+  filename
+}) {
+  const language = filename ? getLanguageFromFilename(filename) : void 0;
+  const theme = useTheme();
+  if (hunks.length === 0) {
+    return /* @__PURE__ */ jsx12(Box12, { paddingX: 1, children: /* @__PURE__ */ jsx12(Text10, { color: theme.colors.muted, children: "No diff available" }) });
+  }
+  const allLines = [];
+  let lineNumber = 1;
+  for (let hunkIndex = 0; hunkIndex < hunks.length; hunkIndex++) {
+    const hunk = hunks[hunkIndex];
+    for (const line of hunk.lines) {
+      allLines.push({ line, lineNumber, hunkIndex });
+      if (line.type !== "header") {
+        lineNumber++;
+      }
+    }
+  }
+  const visibleLines = allLines.slice(
+    scrollOffset,
+    scrollOffset + viewportHeight
+  );
+  return /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", flexGrow: 1, children: visibleLines.map((item, index) => /* @__PURE__ */ jsx12(
+    DiffLineView,
+    {
+      line: item.line,
+      lineNumber: item.lineNumber,
+      isFocus: isActive && scrollOffset + index === selectedLine,
+      language
+    },
+    `${item.hunkIndex}-${scrollOffset + index}`
+  )) });
+}
+function FilesTab({
+  files,
+  isActive
+}) {
+  const { stdout } = useStdout3();
+  const theme = useTheme();
+  const viewportHeight = Math.max(1, (stdout?.rows ?? 24) - 10);
+  const [focusPanel, setFocusPanel] = useState5("tree");
+  const [selectedFileIndex, setSelectedFileIndex] = useState5(0);
+  const tree = useMemo(() => buildFileTree(files), [files]);
+  const fileOrder = useMemo(() => flattenTreeToFiles(tree), [tree]);
+  const displayRows = useMemo(
+    () => buildDisplayRows(tree, 0, { current: 0 }),
+    [tree]
+  );
+  const { selectedIndex: treeSelectedIndex } = useListNavigation({
+    itemCount: fileOrder.length,
+    viewportHeight,
+    isActive: isActive && focusPanel === "tree"
+  });
+  const treeViewportHeight = viewportHeight - 2;
+  const fileTreeListRef = useRef2(null);
+  const selectedRowIndex = displayRows.findIndex(
+    (r) => r.type === "file" && r.fileIndex === treeSelectedIndex
+  );
+  const effectiveRowIndex = selectedRowIndex >= 0 ? selectedRowIndex : 0;
+  useEffect4(() => {
+    const handleResize = () => fileTreeListRef.current?.remeasure();
+    stdout?.on("resize", handleResize);
+    return () => {
+      stdout?.off("resize", handleResize);
+    };
+  }, [stdout]);
+  React5.useEffect(() => {
+    if (focusPanel === "tree") {
+      setSelectedFileIndex(treeSelectedIndex);
+    }
+  }, [treeSelectedIndex, focusPanel]);
+  const selectedFile = fileOrder[selectedFileIndex] ?? fileOrder[0] ?? null;
+  const hunks = selectedFile?.patch ? parseDiffPatch(selectedFile.patch) : [];
+  const totalDiffLines = hunks.reduce((sum, hunk) => sum + hunk.lines.length, 0);
+  const { selectedIndex: diffSelectedLine, scrollOffset: diffScrollOffset } = useListNavigation({
+    itemCount: totalDiffLines,
+    viewportHeight,
+    isActive: isActive && focusPanel === "diff"
+  });
+  useInput3(
+    (input, key) => {
+      if (key.tab) {
+        setFocusPanel((prev) => prev === "tree" ? "diff" : "tree");
+      } else if (input === "h" || key.leftArrow) {
+        setFocusPanel("tree");
+      } else if (input === "l" || key.rightArrow) {
+        setFocusPanel("diff");
+      }
+    },
+    { isActive }
+  );
+  if (files.length === 0) {
+    return /* @__PURE__ */ jsx12(EmptyState, { message: "No files changed" });
+  }
+  const isPanelFocused = focusPanel === "tree" && isActive;
+  return /* @__PURE__ */ jsxs9(Box12, { flexDirection: "row", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs9(
+      Box12,
+      {
+        flexDirection: "column",
+        width: "30%",
+        borderStyle: "single",
+        borderColor: focusPanel === "tree" && isActive ? theme.colors.accent : theme.colors.border,
+        children: [
+          /* @__PURE__ */ jsx12(Box12, { paddingX: 1, paddingY: 0, children: /* @__PURE__ */ jsxs9(Text10, { color: theme.colors.accent, bold: true, children: [
+            "Files (",
+            files.length,
+            ")"
+          ] }) }),
+          /* @__PURE__ */ jsx12(
+            Box12,
+            {
+              flexDirection: "column",
+              paddingX: 1,
+              overflow: "hidden",
+              height: treeViewportHeight,
+              minHeight: treeViewportHeight,
+              flexShrink: 0,
+              children: /* @__PURE__ */ jsx12(
+                ScrollList,
+                {
+                  ref: fileTreeListRef,
+                  selectedIndex: effectiveRowIndex,
+                  scrollAlignment: "auto",
+                  children: displayRows.map(
+                    (row, rowIndex) => row.type === "dir" ? /* @__PURE__ */ jsx12(Box12, { paddingLeft: row.indent * 2, children: /* @__PURE__ */ jsxs9(Text10, { color: theme.colors.muted, children: [
+                      row.name,
+                      "/"
+                    ] }) }, `row-${rowIndex}`) : /* @__PURE__ */ jsx12(Box12, { paddingLeft: row.indent * 2, children: /* @__PURE__ */ jsx12(
+                      FileItem,
+                      {
+                        item: row.file,
+                        isFocus: isPanelFocused && row.fileIndex === treeSelectedIndex,
+                        isSelected: row.fileIndex === selectedFileIndex
+                      }
+                    ) }, `row-${rowIndex}`)
+                  )
+                }
+              )
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs9(
+      Box12,
+      {
+        flexDirection: "column",
+        flexGrow: 1,
+        borderStyle: "single",
+        borderColor: focusPanel === "diff" && isActive ? theme.colors.accent : theme.colors.border,
+        children: [
+          /* @__PURE__ */ jsxs9(Box12, { paddingX: 1, paddingY: 0, gap: 2, children: [
+            /* @__PURE__ */ jsx12(Text10, { color: theme.colors.accent, bold: true, children: selectedFile?.filename ?? "No file selected" }),
+            selectedFile && /* @__PURE__ */ jsxs9(Box12, { gap: 1, children: [
+              /* @__PURE__ */ jsxs9(Text10, { color: theme.colors.diffAdd, children: [
+                "+",
+                selectedFile.additions
+              ] }),
+              /* @__PURE__ */ jsxs9(Text10, { color: theme.colors.diffDel, children: [
+                "-",
+                selectedFile.deletions
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", flexGrow: 1, overflowY: "hidden", children: /* @__PURE__ */ jsx12(
+            DiffView,
+            {
+              hunks,
+              selectedLine: diffSelectedLine,
+              scrollOffset: diffScrollOffset,
+              viewportHeight: viewportHeight - 2,
+              isActive: isActive && focusPanel === "diff",
+              filename: selectedFile?.filename
+            }
+          ) })
+        ]
+      }
+    )
+  ] });
+}
+
+// src/components/pr/ConversationsTab.tsx
+import { useEffect as useEffect5, useRef as useRef3 } from "react";
+import { Box as Box13, Text as Text11, useStdout as useStdout4 } from "ink";
+import { Match } from "effect";
+import { ScrollList as ScrollList2 } from "ink-scroll-list";
+import { Fragment as Fragment2, jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+function buildTimeline(pr, comments, reviews) {
+  const items = [];
+  items.push({
+    id: "description",
+    type: "description",
+    user: pr.user.login,
+    body: pr.body,
+    date: pr.created_at
+  });
+  for (const review of reviews) {
+    if (review.state !== "PENDING") {
+      items.push({
+        id: `review-${review.id}`,
+        type: "review",
+        user: review.user.login,
+        body: review.body,
+        date: review.submitted_at ?? pr.created_at,
+        state: review.state
+      });
+    }
+  }
+  for (const comment of comments) {
+    items.push({
+      id: `comment-${comment.id}`,
+      type: "comment",
+      user: comment.user.login,
+      body: comment.body,
+      date: comment.created_at,
+      path: comment.path,
+      line: comment.line
+    });
+  }
+  items.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+  return items;
+}
+function TimelineItemView({
+  item,
+  isFocus
+}) {
+  const theme = useTheme();
+  const getStateIcon = (state) => Match.value(state).pipe(
+    Match.when("APPROVED", () => ({
+      icon: "\u2713",
+      color: theme.colors.success
+    })),
+    Match.when("CHANGES_REQUESTED", () => ({
+      icon: "\u2717",
+      color: theme.colors.error
+    })),
+    Match.when("COMMENTED", () => ({ icon: "\u{1F4AC}", color: theme.colors.info })),
+    Match.when("DISMISSED", () => ({ icon: "\u2014", color: theme.colors.muted })),
+    Match.orElse(() => ({ icon: "\u2022", color: theme.colors.muted }))
+  );
+  const { icon, color } = item.type === "review" ? getStateIcon(item.state) : item.type === "description" ? { icon: "\u{1F4DD}", color: theme.colors.accent } : { icon: "\u{1F4AC}", color: theme.colors.info };
+  const stateLabel = item.type === "review" && item.state ? item.state.toLowerCase().replace("_", " ") : "";
+  const location = item.type === "comment" && item.path ? ` on ${item.path}${item.line != null ? `:${item.line}` : ""}` : "";
+  return /* @__PURE__ */ jsxs10(
+    Box13,
+    {
+      flexDirection: "column",
+      paddingX: 1,
+      paddingY: 1,
+      marginBottom: 2,
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsxs10(Box13, { flexDirection: "row", children: [
+          isFocus && /* @__PURE__ */ jsx13(Text11, { color: theme.colors.accent, children: "\u25B8 " }),
+          /* @__PURE__ */ jsx13(Text11, { color, children: icon }),
+          /* @__PURE__ */ jsx13(Text11, { children: " " }),
+          /* @__PURE__ */ jsx13(Text11, { color: theme.colors.secondary, bold: true, children: item.user }),
+          stateLabel ? /* @__PURE__ */ jsxs10(Fragment2, { children: [
+            /* @__PURE__ */ jsx13(Text11, { children: " " }),
+            /* @__PURE__ */ jsx13(Text11, { color, children: stateLabel })
+          ] }) : null,
+          location ? /* @__PURE__ */ jsx13(Text11, { color: theme.colors.muted, children: location }) : null,
+          /* @__PURE__ */ jsxs10(Text11, { color: theme.colors.muted, children: [
+            " \xB7 ",
+            timeAgo(item.date)
+          ] })
+        ] }),
+        item.body ? /* @__PURE__ */ jsx13(Box13, { paddingLeft: isFocus ? 3 : 2, marginTop: 0, width: "80%", children: /* @__PURE__ */ jsx13(Text11, { color: theme.colors.text, wrap: "wrap", children: item.body }) }) : null
+      ]
+    }
+  );
+}
+function PRInfoSection({
+  pr
+}) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs10(
+    Box13,
+    {
+      flexDirection: "column",
+      paddingX: 1,
+      paddingY: 1,
+      borderStyle: "single",
+      borderColor: theme.colors.border,
+      children: [
+        /* @__PURE__ */ jsxs10(Box13, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsx13(Text11, { color: theme.colors.muted, children: "Author: " }),
+          /* @__PURE__ */ jsx13(Text11, { color: theme.colors.secondary, bold: true, children: pr.user.login })
+        ] }),
+        pr.requested_reviewers.length > 0 ? /* @__PURE__ */ jsxs10(Box13, { flexDirection: "row", marginTop: 0, children: [
+          /* @__PURE__ */ jsx13(Text11, { color: theme.colors.muted, children: "Reviewers: " }),
+          /* @__PURE__ */ jsx13(Text11, { color: theme.colors.text, children: pr.requested_reviewers.map((r) => r.login).join(", ") })
+        ] }) : null,
+        pr.labels.length > 0 ? /* @__PURE__ */ jsxs10(Box13, { flexDirection: "row", marginTop: 0, children: [
+          /* @__PURE__ */ jsx13(Text11, { color: theme.colors.muted, children: "Labels: " }),
+          pr.labels.map((label) => /* @__PURE__ */ jsxs10(Text11, { color: `#${label.color}`, children: [
+            "[",
+            label.name,
+            "]",
+            " "
+          ] }, label.id))
+        ] }) : null,
+        /* @__PURE__ */ jsx13(Box13, { paddingY: 0, children: /* @__PURE__ */ jsx13(Divider, {}) }),
+        /* @__PURE__ */ jsxs10(Box13, { flexDirection: "row", marginTop: 0, children: [
+          /* @__PURE__ */ jsxs10(Text11, { color: theme.colors.diffAdd, children: [
+            "+",
+            pr.additions
+          ] }),
+          /* @__PURE__ */ jsx13(Text11, { children: " " }),
+          /* @__PURE__ */ jsxs10(Text11, { color: theme.colors.diffDel, children: [
+            "-",
+            pr.deletions
+          ] }),
+          /* @__PURE__ */ jsxs10(Text11, { color: theme.colors.muted, children: [
+            " ",
+            pr.changed_files,
+            " files changed"
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+var CONVERSATIONS_RESERVED_LINES = 18;
+function ConversationsTab({
+  pr,
+  comments,
+  reviews,
+  isActive
+}) {
+  const theme = useTheme();
+  const { stdout } = useStdout4();
+  const listRef = useRef3(null);
+  const timeline = buildTimeline(pr, comments, reviews);
+  const viewportHeight = Math.max(1, (stdout?.rows ?? 24) - CONVERSATIONS_RESERVED_LINES);
+  const { selectedIndex } = useListNavigation({
+    itemCount: timeline.length,
+    viewportHeight,
+    isActive
+  });
+  useEffect5(() => {
+    const handleResize = () => {
+      listRef.current?.remeasure();
+    };
+    stdout?.on("resize", handleResize);
+    return () => {
+      stdout?.off("resize", handleResize);
+    };
+  }, [stdout]);
+  return /* @__PURE__ */ jsxs10(Box13, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx13(PRInfoSection, { pr }),
+    /* @__PURE__ */ jsx13(Box13, { flexDirection: "row", paddingX: 1, paddingY: 0, marginBottom: 1, children: /* @__PURE__ */ jsxs10(Text11, { color: theme.colors.accent, bold: true, children: [
+      "Timeline (",
+      timeline.length,
+      " items)"
+    ] }) }),
+    /* @__PURE__ */ jsx13(Box13, { flexDirection: "column", flexGrow: 1, overflow: "hidden", height: viewportHeight, children: timeline.length === 0 ? /* @__PURE__ */ jsx13(Box13, { paddingX: 1, children: /* @__PURE__ */ jsx13(Text11, { color: theme.colors.muted, children: "No conversations yet" }) }) : /* @__PURE__ */ jsx13(
+      ScrollList2,
+      {
+        ref: listRef,
+        selectedIndex,
+        scrollAlignment: "auto",
+        children: timeline.map((item, index) => /* @__PURE__ */ jsx13(
+          TimelineItemView,
+          {
+            item,
+            isFocus: index === selectedIndex
+          },
+          item.id
+        ))
+      }
+    ) })
+  ] });
+}
+
+// src/components/pr/CommitsTab.tsx
+import { useEffect as useEffect6, useRef as useRef4 } from "react";
+import { Box as Box14, Text as Text12, useStdout as useStdout5 } from "ink";
+import { ScrollList as ScrollList3 } from "ink-scroll-list";
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+function CommitItem({
+  commit,
+  isFocus
+}) {
+  const theme = useTheme();
+  const shortSha = commit.sha.slice(0, 7);
+  const message = commit.commit.message.split("\n")[0] ?? "";
+  const author = commit.author?.login ?? commit.commit.author.name;
+  const date = commit.commit.author.date;
+  return /* @__PURE__ */ jsxs11(
+    Box14,
+    {
+      paddingX: 1,
+      paddingY: 0,
+      gap: 1,
+      backgroundColor: isFocus ? theme.colors.selection : void 0,
+      children: [
+        /* @__PURE__ */ jsx14(Box14, { width: 10, children: /* @__PURE__ */ jsx14(Text12, { color: theme.colors.warning, bold: isFocus, children: shortSha }) }),
+        /* @__PURE__ */ jsx14(Box14, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx14(
+          Text12,
+          {
+            color: isFocus ? theme.colors.listSelectedFg : theme.colors.text,
+            bold: isFocus,
+            wrap: "truncate",
+            children: message
+          }
+        ) }),
+        /* @__PURE__ */ jsx14(Box14, { width: 16, children: /* @__PURE__ */ jsx14(Text12, { color: theme.colors.secondary, children: author }) }),
+        /* @__PURE__ */ jsx14(Box14, { width: 14, children: /* @__PURE__ */ jsx14(Text12, { color: theme.colors.muted, children: timeAgo(date) }) })
+      ]
+    }
+  );
+}
+function CommitsTab({
+  commits,
+  isActive
+}) {
+  const { stdout } = useStdout5();
+  const theme = useTheme();
+  const viewportHeight = Math.max(1, (stdout?.rows ?? 24) - 10);
+  const listRef = useRef4(null);
+  const { selectedIndex } = useListNavigation({
+    itemCount: commits.length,
+    viewportHeight,
+    isActive
+  });
+  useEffect6(() => {
+    const handleResize = () => listRef.current?.remeasure();
+    stdout?.on("resize", handleResize);
+    return () => {
+      stdout?.off("resize", handleResize);
+    };
+  }, [stdout]);
+  if (commits.length === 0) {
+    return /* @__PURE__ */ jsx14(EmptyState, { message: "No commits found" });
+  }
+  return /* @__PURE__ */ jsxs11(Box14, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs11(Box14, { paddingX: 1, paddingY: 1, gap: 1, children: [
+      /* @__PURE__ */ jsx14(Text12, { color: theme.colors.accent, bold: true, children: "Commits" }),
+      /* @__PURE__ */ jsxs11(Text12, { color: theme.colors.muted, children: [
+        "(",
+        commits.length,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs11(
+      Box14,
+      {
+        paddingX: 1,
+        paddingBottom: 1,
+        gap: 1,
+        borderStyle: "single",
+        borderColor: theme.colors.border,
+        borderTop: false,
+        borderLeft: false,
+        borderRight: false,
+        children: [
+          /* @__PURE__ */ jsx14(Box14, { width: 10, children: /* @__PURE__ */ jsx14(Text12, { color: theme.colors.muted, bold: true, children: "SHA" }) }),
+          /* @__PURE__ */ jsx14(Box14, { flexGrow: 1, children: /* @__PURE__ */ jsx14(Text12, { color: theme.colors.muted, bold: true, children: "Message" }) }),
+          /* @__PURE__ */ jsx14(Box14, { width: 16, children: /* @__PURE__ */ jsx14(Text12, { color: theme.colors.muted, bold: true, children: "Author" }) }),
+          /* @__PURE__ */ jsx14(Box14, { width: 14, children: /* @__PURE__ */ jsx14(Text12, { color: theme.colors.muted, bold: true, children: "Date" }) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx14(Box14, { flexDirection: "column", overflow: "hidden", height: viewportHeight, children: /* @__PURE__ */ jsx14(ScrollList3, { ref: listRef, selectedIndex, scrollAlignment: "auto", children: commits.map((commit, index) => /* @__PURE__ */ jsx14(
+      CommitItem,
+      {
+        commit,
+        isFocus: index === selectedIndex
+      },
+      commit.sha
+    )) }) })
+  ] });
+}
+
+// src/components/common/LoadingIndicator.tsx
+import { Box as Box15, Text as Text13, useStdout as useStdout6 } from "ink";
+import { Spinner as Spinner2 } from "@inkjs/ui";
+import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+function LoadingIndicator({
+  message = "Loading..."
+}) {
+  const theme = useTheme();
+  const { stdout } = useStdout6();
+  const height = stdout?.rows ?? 24;
+  return /* @__PURE__ */ jsx15(
+    Box15,
+    {
+      flexDirection: "column",
+      justifyContent: "center",
+      alignItems: "center",
+      height: height - 4,
+      flexGrow: 1,
+      children: /* @__PURE__ */ jsxs12(Box15, { gap: 1, children: [
+        /* @__PURE__ */ jsx15(Spinner2, {}),
+        /* @__PURE__ */ jsx15(Text13, { color: theme.colors.accent, children: message })
+      ] })
+    }
+  );
+}
+
+// src/screens/PRDetailScreen.tsx
+import { jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
+var PR_DETAIL_RESERVED_LINES = 12;
+function PRDetailScreen({
+  pr,
+  owner,
+  repo,
+  onBack
+}) {
+  const { stdout } = useStdout7();
+  const [currentTab, setCurrentTab] = useState6(0);
+  const contentHeight = Math.max(1, (stdout?.rows ?? 24) - PR_DETAIL_RESERVED_LINES);
+  const { data: files = [], isLoading: filesLoading } = usePRFiles(owner, repo, pr.number);
+  const { data: comments = [], isLoading: commentsLoading } = usePRComments(owner, repo, pr.number);
+  const { data: reviews = [], isLoading: reviewsLoading } = usePRReviews(owner, repo, pr.number);
+  const { data: commits = [], isLoading: commitsLoading } = usePRCommits(owner, repo, pr.number);
+  const isLoading = filesLoading || commentsLoading || reviewsLoading || commitsLoading;
+  useInput4((input, key) => {
+    if (input === "1") {
+      setCurrentTab(0);
+    } else if (input === "2") {
+      setCurrentTab(1);
+    } else if (input === "3") {
+      setCurrentTab(2);
+    } else if (input === "q" || key.escape) {
+      onBack();
+    }
+  });
+  const renderTabContent = () => {
+    if (isLoading) {
+      return /* @__PURE__ */ jsx16(LoadingIndicator, { message: "Loading PR details..." });
+    }
+    return Match2.value(currentTab).pipe(
+      Match2.when(0, () => /* @__PURE__ */ jsx16(
+        ConversationsTab,
+        {
+          pr,
+          comments,
+          reviews,
+          isActive: true
+        }
+      )),
+      Match2.when(1, () => /* @__PURE__ */ jsx16(CommitsTab, { commits, isActive: true })),
+      Match2.when(2, () => /* @__PURE__ */ jsx16(FilesTab, { files, isActive: true })),
+      Match2.orElse(() => /* @__PURE__ */ jsx16(
+        ConversationsTab,
+        {
+          pr,
+          comments,
+          reviews,
+          isActive: true
+        }
+      ))
+    );
+  };
+  return /* @__PURE__ */ jsxs13(Box16, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx16(PRHeader, { pr }),
+    /* @__PURE__ */ jsx16(PRTabs, { activeIndex: currentTab, onChange: setCurrentTab }),
+    /* @__PURE__ */ jsx16(Box16, { height: contentHeight, overflow: "hidden", flexDirection: "column", children: renderTabContent() })
+  ] });
+}
+
+// src/screens/MyPRsScreen.tsx
+import { useState as useState10 } from "react";
+import { Box as Box21, Text as Text18, useInput as useInput7 } from "ink";
+
+// src/hooks/usePagination.ts
+import { useState as useState7, useMemo as useMemo2, useCallback as useCallback3, useEffect as useEffect7, useRef as useRef5 } from "react";
+function usePagination(items, options = {}) {
+  const pageSize = options.pageSize ?? 18;
+  const [currentPage, setCurrentPage] = useState7(1);
+  const prevItemsLengthRef = useRef5(items.length);
+  const totalPages = useMemo2(
+    () => Math.max(1, Math.ceil(items.length / pageSize)),
+    [items.length, pageSize]
+  );
+  useEffect7(() => {
+    if (items.length !== prevItemsLengthRef.current) {
+      setCurrentPage(1);
+      prevItemsLengthRef.current = items.length;
+    }
+  }, [items.length]);
+  const safePage = Math.min(currentPage, totalPages);
+  const startIndex = (safePage - 1) * pageSize;
+  const endIndex = Math.min(startIndex + pageSize, items.length);
+  const pageItems = useMemo2(
+    () => items.slice(startIndex, endIndex),
+    [items, startIndex, endIndex]
+  );
+  const hasNextPage = safePage < totalPages;
+  const hasPrevPage = safePage > 1;
+  const nextPage = useCallback3(() => {
+    if (hasNextPage) {
+      setCurrentPage((p) => p + 1);
+    }
+  }, [hasNextPage]);
+  const prevPage = useCallback3(() => {
+    if (hasPrevPage) {
+      setCurrentPage((p) => p - 1);
+    }
+  }, [hasPrevPage]);
+  const goToPage = useCallback3(
+    (page) => {
+      const clampedPage = Math.max(1, Math.min(page, totalPages));
+      setCurrentPage(clampedPage);
+    },
+    [totalPages]
+  );
+  return {
+    currentPage: safePage,
+    totalPages,
+    pageItems,
+    hasNextPage,
+    hasPrevPage,
+    nextPage,
+    prevPage,
+    goToPage,
+    startIndex,
+    endIndex
+  };
+}
+
+// src/hooks/useFilter.ts
+import { useState as useState8, useMemo as useMemo3, useCallback as useCallback4 } from "react";
+var defaultFilter = {
+  search: "",
+  repo: null,
+  author: null,
+  label: null,
+  sortBy: "updated",
+  sortDirection: "desc"
+};
+function extractRepoFromUrl(url) {
+  const match = url.match(/github\.com\/([^/]+\/[^/]+)\/pull/);
+  return match?.[1] ?? null;
+}
+function matchesSearch(pr, search) {
+  if (!search) return true;
+  const lowerSearch = search.toLowerCase();
+  return pr.title.toLowerCase().includes(lowerSearch) || pr.user.login.toLowerCase().includes(lowerSearch) || String(pr.number).includes(lowerSearch);
+}
+function matchesRepo(pr, repo) {
+  if (!repo) return true;
+  const prRepo = extractRepoFromUrl(pr.html_url);
+  return prRepo?.toLowerCase().includes(repo.toLowerCase()) ?? false;
+}
+function matchesAuthor(pr, author) {
+  if (!author) return true;
+  return pr.user.login.toLowerCase().includes(author.toLowerCase());
+}
+function matchesLabel(pr, label) {
+  if (!label) return true;
+  const lowerLabel = label.toLowerCase();
+  return pr.labels.some((l) => l.name.toLowerCase().includes(lowerLabel));
+}
+function comparePRs(a, b, sortBy, sortDirection) {
+  let comparison = 0;
+  switch (sortBy) {
+    case "updated":
+      comparison = new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime();
+      break;
+    case "created":
+      comparison = new Date(b.created_at).getTime() - new Date(a.created_at).getTime();
+      break;
+    case "repo": {
+      const repoA = extractRepoFromUrl(a.html_url) ?? "";
+      const repoB = extractRepoFromUrl(b.html_url) ?? "";
+      comparison = repoA.localeCompare(repoB);
+      break;
+    }
+    case "author":
+      comparison = a.user.login.localeCompare(b.user.login);
+      break;
+    case "title":
+      comparison = a.title.localeCompare(b.title);
+      break;
+  }
+  return sortDirection === "asc" ? -comparison : comparison;
+}
+function useFilter(items) {
+  const [filter, setFilter] = useState8(defaultFilter);
+  const availableRepos = useMemo3(() => {
+    const repos = /* @__PURE__ */ new Set();
+    items.forEach((pr) => {
+      const repo = extractRepoFromUrl(pr.html_url);
+      if (repo) repos.add(repo);
+    });
+    return Array.from(repos).sort();
+  }, [items]);
+  const availableAuthors = useMemo3(() => {
+    const authors = /* @__PURE__ */ new Set();
+    items.forEach((pr) => authors.add(pr.user.login));
+    return Array.from(authors).sort();
+  }, [items]);
+  const availableLabels = useMemo3(() => {
+    const labels = /* @__PURE__ */ new Set();
+    items.forEach((pr) => pr.labels.forEach((l) => labels.add(l.name)));
+    return Array.from(labels).sort();
+  }, [items]);
+  const filteredItems = useMemo3(() => {
+    return items.filter((pr) => matchesSearch(pr, filter.search)).filter((pr) => matchesRepo(pr, filter.repo)).filter((pr) => matchesAuthor(pr, filter.author)).filter((pr) => matchesLabel(pr, filter.label)).sort((a, b) => comparePRs(a, b, filter.sortBy, filter.sortDirection));
+  }, [items, filter]);
+  const setSearch = useCallback4((search) => {
+    setFilter((prev) => ({ ...prev, search }));
+  }, []);
+  const setRepo = useCallback4((repo) => {
+    setFilter((prev) => ({ ...prev, repo }));
+  }, []);
+  const setAuthor = useCallback4((author) => {
+    setFilter((prev) => ({ ...prev, author }));
+  }, []);
+  const setLabel = useCallback4((label) => {
+    setFilter((prev) => ({ ...prev, label }));
+  }, []);
+  const setSortBy = useCallback4((sortBy) => {
+    setFilter((prev) => ({ ...prev, sortBy }));
+  }, []);
+  const toggleSortDirection = useCallback4(() => {
+    setFilter((prev) => ({
+      ...prev,
+      sortDirection: prev.sortDirection === "asc" ? "desc" : "asc"
+    }));
+  }, []);
+  const clearFilters = useCallback4(() => {
+    setFilter(defaultFilter);
+  }, []);
+  const hasActiveFilters = filter.search !== "" || filter.repo !== null || filter.author !== null || filter.label !== null;
+  return {
+    filter,
+    filteredItems,
+    setSearch,
+    setRepo,
+    setAuthor,
+    setLabel,
+    setSortBy,
+    toggleSortDirection,
+    clearFilters,
+    hasActiveFilters,
+    availableRepos,
+    availableAuthors,
+    availableLabels
+  };
+}
+
+// src/components/pr/PRListItem.tsx
+import { Box as Box17, Text as Text14 } from "ink";
+import { Fragment as Fragment3, jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
+function extractRepoFromUrl2(url) {
+  const match = url.match(/github\.com\/([^/]+\/[^/]+)\/pull/);
+  return match?.[1] ?? null;
+}
+function PRListItem({
+  item,
+  isFocus
+}) {
+  const theme = useTheme();
+  const stateColor = item.draft ? theme.colors.muted : item.state === "open" ? theme.colors.success : theme.colors.error;
+  const stateIcon = item.draft ? "D" : item.state === "open" ? "O" : "C";
+  const repoName = extractRepoFromUrl2(item.html_url);
+  return /* @__PURE__ */ jsxs14(Box17, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs14(Box17, { gap: 1, children: [
+      /* @__PURE__ */ jsx17(Text14, { color: stateColor, bold: true, children: stateIcon }),
+      /* @__PURE__ */ jsxs14(
+        Text14,
+        {
+          color: isFocus ? theme.colors.listSelectedFg : theme.colors.text,
+          bold: isFocus,
+          inverse: isFocus,
+          children: [
+            "#",
+            item.number
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx17(
+        Text14,
+        {
+          color: isFocus ? theme.colors.listSelectedFg : theme.colors.text,
+          bold: isFocus,
+          inverse: isFocus,
+          children: item.title
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs14(Box17, { gap: 1, paddingLeft: 3, children: [
+      repoName && /* @__PURE__ */ jsxs14(Fragment3, { children: [
+        /* @__PURE__ */ jsx17(Text14, { color: theme.colors.secondary, children: repoName }),
+        /* @__PURE__ */ jsx17(Text14, { color: theme.colors.muted, children: "|" })
+      ] }),
+      /* @__PURE__ */ jsx17(Text14, { color: theme.colors.muted, children: item.user.login }),
+      /* @__PURE__ */ jsx17(Text14, { color: theme.colors.muted, children: "|" }),
+      /* @__PURE__ */ jsx17(Text14, { color: theme.colors.muted, children: timeAgo(item.created_at) }),
+      item.requested_reviewers.length > 0 && /* @__PURE__ */ jsxs14(Fragment3, { children: [
+        /* @__PURE__ */ jsx17(Text14, { color: theme.colors.muted, children: "|" }),
+        /* @__PURE__ */ jsx17(Text14, { color: theme.colors.info, children: item.requested_reviewers.map((r) => r.login).join(", ") })
+      ] }),
+      item.comments > 0 && /* @__PURE__ */ jsxs14(Fragment3, { children: [
+        /* @__PURE__ */ jsx17(Text14, { color: theme.colors.muted, children: "|" }),
+        /* @__PURE__ */ jsxs14(Text14, { color: theme.colors.muted, children: [
+          item.comments,
+          " comments"
+        ] })
+      ] }),
+      item.labels.length > 0 && /* @__PURE__ */ jsxs14(Fragment3, { children: [
+        /* @__PURE__ */ jsx17(Text14, { color: theme.colors.muted, children: "|" }),
+        item.labels.map(
+          (label) => /* @__PURE__ */ jsxs14(Text14, { color: `#${label.color}`, children: [
+            "[",
+            label.name,
+            "]"
+          ] }, label.id)
+        )
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/common/PaginationBar.tsx
+import { Box as Box18, Text as Text15 } from "ink";
+import { jsx as jsx18, jsxs as jsxs15 } from "react/jsx-runtime";
+function PaginationBar({
+  currentPage,
+  totalPages,
+  totalItems,
+  startIndex,
+  endIndex,
+  hasNextPage,
+  hasPrevPage
+}) {
+  const theme = useTheme();
+  if (totalPages <= 1) {
+    return /* @__PURE__ */ jsx18(Box18, { paddingX: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: theme.colors.muted, children: [
+      totalItems,
+      " item",
+      totalItems !== 1 ? "s" : ""
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs15(Box18, { paddingX: 1, gap: 2, children: [
+    /* @__PURE__ */ jsxs15(Text15, { color: theme.colors.muted, children: [
+      startIndex + 1,
+      "-",
+      endIndex,
+      " of ",
+      totalItems
+    ] }),
+    /* @__PURE__ */ jsxs15(Box18, { gap: 1, children: [
+      /* @__PURE__ */ jsx18(Text15, { color: hasPrevPage ? theme.colors.accent : theme.colors.muted, children: hasPrevPage ? "\u2190 [p]rev" : "\u2190 prev" }),
+      /* @__PURE__ */ jsx18(Text15, { color: theme.colors.muted, children: "\u2502" }),
+      /* @__PURE__ */ jsxs15(Text15, { color: theme.colors.text, children: [
+        "Page ",
+        currentPage,
+        "/",
+        totalPages
+      ] }),
+      /* @__PURE__ */ jsx18(Text15, { color: theme.colors.muted, children: "\u2502" }),
+      /* @__PURE__ */ jsx18(Text15, { color: hasNextPage ? theme.colors.accent : theme.colors.muted, children: hasNextPage ? "[n]ext \u2192" : "next \u2192" })
+    ] })
+  ] });
+}
+
+// src/components/common/FilterModal.tsx
+import { useState as useState9, useEffect as useEffect8 } from "react";
+import { Box as Box19, Text as Text16, useInput as useInput5 } from "ink";
+import { TextInput as TextInput2 } from "@inkjs/ui";
+import { jsx as jsx19, jsxs as jsxs16 } from "react/jsx-runtime";
+function FilterModal({
+  filter,
+  onSearchChange,
+  onClear,
+  onClose
+}) {
+  const theme = useTheme();
+  const { setInputActive } = useInputFocus();
+  const [searchValue, setSearchValue] = useState9(filter.search);
+  const [showClearConfirm, setShowClearConfirm] = useState9(false);
+  useEffect8(() => {
+    setInputActive(true);
+    return () => setInputActive(false);
+  }, [setInputActive]);
+  useInput5((input, key) => {
+    if (showClearConfirm) {
+      if (input === "y" || input === "Y") {
+        onClear();
+        onClose();
+      } else if (input === "n" || input === "N" || key.escape) {
+        setShowClearConfirm(false);
+      }
+      return;
+    }
+    if (key.escape) {
+      onClose();
+    } else if (key.return) {
+      onSearchChange(searchValue);
+      onClose();
+    } else if (input === "c" && filter.search) {
+      setShowClearConfirm(true);
+    }
+  });
+  if (showClearConfirm) {
+    return /* @__PURE__ */ jsx19(Modal, { children: /* @__PURE__ */ jsxs16(
+      Box19,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: theme.colors.accent,
+        backgroundColor: theme.colors.bg,
+        paddingX: 2,
+        paddingY: 1,
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx19(Text16, { color: theme.colors.accent, bold: true, children: "Clear all filters?" }),
+          /* @__PURE__ */ jsx19(Text16, { color: theme.colors.text, children: "y: Yes, n: No" })
+        ]
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx19(Modal, { children: /* @__PURE__ */ jsxs16(
+    Box19,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.colors.accent,
+      backgroundColor: theme.colors.bg,
+      paddingX: 2,
+      paddingY: 1,
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx19(Text16, { color: theme.colors.accent, bold: true, children: "Search PRs" }),
+        /* @__PURE__ */ jsx19(Text16, { color: theme.colors.muted, children: "Filter by title, number, or author" }),
+        /* @__PURE__ */ jsx19(Box19, { children: /* @__PURE__ */ jsx19(
+          TextInput2,
+          {
+            defaultValue: searchValue,
+            onChange: setSearchValue,
+            placeholder: "Type to search..."
+          }
+        ) }),
+        /* @__PURE__ */ jsxs16(Text16, { color: theme.colors.muted, dimColor: true, children: [
+          "Enter: apply | Esc: cancel",
+          filter.search ? " | c: clear" : ""
+        ] })
+      ]
+    }
+  ) });
+}
+
+// src/components/common/SortModal.tsx
+import { useMemo as useMemo4 } from "react";
+import { Box as Box20, Text as Text17, useInput as useInput6 } from "ink";
+import SelectInput from "ink-select-input";
+import { jsx as jsx20, jsxs as jsxs17 } from "react/jsx-runtime";
+var SORT_OPTIONS = [
+  { key: "updated", label: "Last Updated" },
+  { key: "created", label: "Created Date" },
+  { key: "repo", label: "Repository" },
+  { key: "author", label: "Author" },
+  { key: "title", label: "Title" }
+];
+function SortModal({
+  currentSort,
+  sortDirection,
+  onSortChange,
+  onSortDirectionToggle,
+  onClose
+}) {
+  const theme = useTheme();
+  useInput6((input, key) => {
+    if (key.escape || input === "s") {
+      onClose();
+    }
+  });
+  const items = useMemo4(
+    () => SORT_OPTIONS.map((option) => ({
+      label: `${option.label}${option.key === currentSort ? sortDirection === "desc" ? " \u2193" : " \u2191" : ""}`,
+      value: option.key
+    })),
+    [currentSort, sortDirection]
+  );
+  const initialIndex = Math.max(
+    0,
+    SORT_OPTIONS.findIndex((o) => o.key === currentSort)
+  );
+  const handleSelect = (item) => {
+    if (item.value === currentSort) {
+      onSortDirectionToggle();
+    } else {
+      onSortChange(item.value);
+    }
+    onClose();
+  };
+  return /* @__PURE__ */ jsx20(Modal, { children: /* @__PURE__ */ jsxs17(
+    Box20,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.colors.accent,
+      backgroundColor: theme.colors.bg,
+      paddingX: 2,
+      paddingY: 1,
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx20(Text17, { color: theme.colors.accent, bold: true, children: "Sort by" }),
+        /* @__PURE__ */ jsx20(
+          SelectInput,
+          {
+            items,
+            initialIndex,
+            onSelect: handleSelect,
+            isFocused: true
+          }
+        ),
+        /* @__PURE__ */ jsx20(Text17, { color: theme.colors.muted, dimColor: true, children: "j/k: move | Enter: select | Esc: close" })
+      ]
+    }
+  ) });
+}
+
+// src/screens/MyPRsScreen.tsx
+import { jsx as jsx21, jsxs as jsxs18 } from "react/jsx-runtime";
+function MyPRsScreen({
+  onSelect
+}) {
+  const theme = useTheme();
+  const { data: prs = [], isLoading, error } = useMyPRs();
+  const [showFilter, setShowFilter] = useState10(false);
+  const [showSort, setShowSort] = useState10(false);
+  const {
+    filter,
+    filteredItems,
+    setSearch,
+    setRepo,
+    setAuthor,
+    setLabel,
+    setSortBy,
+    toggleSortDirection,
+    clearFilters,
+    hasActiveFilters,
+    availableRepos,
+    availableAuthors,
+    availableLabels
+  } = useFilter(prs);
+  const {
+    currentPage,
+    totalPages,
+    pageItems,
+    hasNextPage,
+    hasPrevPage,
+    nextPage,
+    prevPage,
+    startIndex,
+    endIndex
+  } = usePagination(filteredItems, { pageSize: 18 });
+  const { selectedIndex } = useListNavigation({
+    itemCount: pageItems.length,
+    viewportHeight: pageItems.length,
+    isActive: !showFilter && !showSort
+  });
+  useInput7(
+    (input, key) => {
+      if (key.return && pageItems[selectedIndex]) {
+        onSelect(pageItems[selectedIndex]);
+      } else if (input === "n" && hasNextPage) {
+        nextPage();
+      } else if (input === "p" && hasPrevPage) {
+        prevPage();
+      } else if (input === "/") {
+        setShowFilter(true);
+      } else if (input === "s") {
+        setShowSort(true);
+      }
+    },
+    { isActive: !showFilter && !showSort }
+  );
+  if (isLoading && prs.length === 0) {
+    return /* @__PURE__ */ jsx21(LoadingIndicator, { message: "Loading your PRs..." });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx21(Box21, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs18(Text18, { color: theme.colors.error, children: [
+      "Error: ",
+      String(error)
+    ] }) });
+  }
+  if (prs.length === 0) {
+    return /* @__PURE__ */ jsx21(EmptyState, { message: "You have no open pull requests" });
+  }
+  return /* @__PURE__ */ jsxs18(Box21, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs18(Box21, { paddingX: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs18(Box21, { gap: 2, children: [
+        /* @__PURE__ */ jsx21(Text18, { color: theme.colors.accent, bold: true, children: "My Pull Requests" }),
+        hasActiveFilters && /* @__PURE__ */ jsx21(Text18, { color: theme.colors.warning, children: "(filtered)" }),
+        /* @__PURE__ */ jsx21(Text18, { color: theme.colors.muted, children: "/ filter s sort" })
+      ] }),
+      /* @__PURE__ */ jsx21(
+        PaginationBar,
+        {
+          currentPage,
+          totalPages,
+          totalItems: filteredItems.length,
+          startIndex,
+          endIndex,
+          hasNextPage,
+          hasPrevPage
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx21(Box21, { flexDirection: "column", children: pageItems.length === 0 ? /* @__PURE__ */ jsx21(Box21, { padding: 1, children: /* @__PURE__ */ jsx21(Text18, { color: theme.colors.muted, children: "No PRs match the current filters" }) }) : pageItems.map((pr, index) => /* @__PURE__ */ jsx21(
+      PRListItem,
+      {
+        item: pr,
+        isFocus: index === selectedIndex
+      },
+      pr.id
+    )) }),
+    showFilter && /* @__PURE__ */ jsx21(
+      FilterModal,
+      {
+        filter,
+        availableRepos,
+        availableAuthors,
+        availableLabels,
+        onSearchChange: setSearch,
+        onRepoChange: setRepo,
+        onAuthorChange: setAuthor,
+        onLabelChange: setLabel,
+        onSortChange: setSortBy,
+        onSortDirectionToggle: toggleSortDirection,
+        onClear: clearFilters,
+        onClose: () => setShowFilter(false)
+      }
+    ),
+    showSort && /* @__PURE__ */ jsx21(
+      SortModal,
+      {
+        currentSort: filter.sortBy,
+        sortDirection: filter.sortDirection,
+        onSortChange: setSortBy,
+        onSortDirectionToggle: toggleSortDirection,
+        onClose: () => setShowSort(false)
+      }
+    )
+  ] });
+}
+
+// src/screens/ReviewRequestsScreen.tsx
+import { useState as useState11 } from "react";
+import { Box as Box22, Text as Text19, useInput as useInput8 } from "ink";
+import { jsx as jsx22, jsxs as jsxs19 } from "react/jsx-runtime";
+function ReviewRequestsScreen({
+  onSelect
+}) {
+  const theme = useTheme();
+  const { data: prs = [], isLoading, error } = useReviewRequests();
+  const [showFilter, setShowFilter] = useState11(false);
+  const [showSort, setShowSort] = useState11(false);
+  const {
+    filter,
+    filteredItems,
+    setSearch,
+    setRepo,
+    setAuthor,
+    setLabel,
+    setSortBy,
+    toggleSortDirection,
+    clearFilters,
+    hasActiveFilters,
+    availableRepos,
+    availableAuthors,
+    availableLabels
+  } = useFilter(prs);
+  const {
+    currentPage,
+    totalPages,
+    pageItems,
+    hasNextPage,
+    hasPrevPage,
+    nextPage,
+    prevPage,
+    startIndex,
+    endIndex
+  } = usePagination(filteredItems, { pageSize: 18 });
+  const { selectedIndex } = useListNavigation({
+    itemCount: pageItems.length,
+    viewportHeight: pageItems.length,
+    isActive: !showFilter && !showSort
+  });
+  useInput8(
+    (input, key) => {
+      if (key.return && pageItems[selectedIndex]) {
+        onSelect(pageItems[selectedIndex]);
+      } else if (input === "n" && hasNextPage) {
+        nextPage();
+      } else if (input === "p" && hasPrevPage) {
+        prevPage();
+      } else if (input === "/") {
+        setShowFilter(true);
+      } else if (input === "s") {
+        setShowSort(true);
+      }
+    },
+    { isActive: !showFilter && !showSort }
+  );
+  if (isLoading && prs.length === 0) {
+    return /* @__PURE__ */ jsx22(LoadingIndicator, { message: "Loading review requests..." });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx22(Box22, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs19(Text19, { color: theme.colors.error, children: [
+      "Error: ",
+      String(error)
+    ] }) });
+  }
+  if (prs.length === 0) {
+    return /* @__PURE__ */ jsx22(EmptyState, { message: "No review requests" });
+  }
+  return /* @__PURE__ */ jsxs19(Box22, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs19(Box22, { paddingX: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs19(Box22, { gap: 2, children: [
+        /* @__PURE__ */ jsx22(Text19, { color: theme.colors.accent, bold: true, children: "For Review" }),
+        hasActiveFilters && /* @__PURE__ */ jsx22(Text19, { color: theme.colors.warning, children: "(filtered)" }),
+        /* @__PURE__ */ jsx22(Text19, { color: theme.colors.muted, children: "/ filter  s sort" })
+      ] }),
+      /* @__PURE__ */ jsx22(
+        PaginationBar,
+        {
+          currentPage,
+          totalPages,
+          totalItems: filteredItems.length,
+          startIndex,
+          endIndex,
+          hasNextPage,
+          hasPrevPage
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx22(Box22, { flexDirection: "column", children: pageItems.length === 0 ? /* @__PURE__ */ jsx22(Box22, { padding: 1, children: /* @__PURE__ */ jsx22(Text19, { color: theme.colors.muted, children: "No PRs match the current filters" }) }) : pageItems.map((pr, index) => /* @__PURE__ */ jsx22(
+      PRListItem,
+      {
+        item: pr,
+        isFocus: index === selectedIndex
+      },
+      pr.id
+    )) }),
+    showFilter && /* @__PURE__ */ jsx22(
+      FilterModal,
+      {
+        filter,
+        availableRepos,
+        availableAuthors,
+        availableLabels,
+        onSearchChange: setSearch,
+        onRepoChange: setRepo,
+        onAuthorChange: setAuthor,
+        onLabelChange: setLabel,
+        onSortChange: setSortBy,
+        onSortDirectionToggle: toggleSortDirection,
+        onClear: clearFilters,
+        onClose: () => setShowFilter(false)
+      }
+    ),
+    showSort && /* @__PURE__ */ jsx22(
+      SortModal,
+      {
+        currentSort: filter.sortBy,
+        sortDirection: filter.sortDirection,
+        onSortChange: setSortBy,
+        onSortDirectionToggle: toggleSortDirection,
+        onClose: () => setShowSort(false)
+      }
+    )
+  ] });
+}
+
+// src/screens/SettingsScreen.tsx
+import { useState as useState12 } from "react";
+import { Box as Box23, Text as Text20, useInput as useInput9 } from "ink";
+import { TextInput as TextInput3 } from "@inkjs/ui";
+
+// src/hooks/useConfig.ts
+import { useQuery as useQuery2, useMutation, useQueryClient } from "@tanstack/react-query";
+import { Effect as Effect5 } from "effect";
+function useConfig() {
+  const queryClient2 = useQueryClient();
+  const { data, error, isLoading } = useQuery2({
+    queryKey: ["config"],
+    queryFn: () => Effect5.runPromise(
+      Effect5.gen(function* () {
+        const configService = yield* Config;
+        return yield* configService.load();
+      }).pipe(Effect5.provide(ConfigLive))
+    )
+  });
+  const mutation = useMutation({
+    mutationFn: (newConfig) => Effect5.runPromise(
+      Effect5.gen(function* () {
+        const configService = yield* Config;
+        yield* configService.save(newConfig);
+      }).pipe(Effect5.provide(ConfigLive))
+    ),
+    onSuccess: () => {
+      queryClient2.invalidateQueries({ queryKey: ["config"] });
+    }
+  });
+  const updateConfig = (updates) => {
+    if (!data) return;
+    const newConfig = { ...data, ...updates };
+    queryClient2.setQueryData(["config"], newConfig);
+    mutation.mutate(newConfig);
+  };
+  return {
+    config: data ?? null,
+    error: error ? String(error) : null,
+    loading: isLoading,
+    updateConfig
+  };
+}
+
+// src/hooks/useAuth.ts
+import { useQuery as useQuery3, useMutation as useMutation2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+import { Effect as Effect6 } from "effect";
+function useAuth() {
+  const queryClient2 = useQueryClient2();
+  const { data, error, isLoading, refetch } = useQuery3({
+    queryKey: ["auth"],
+    queryFn: () => Effect6.runPromise(
+      Effect6.gen(function* () {
+        const auth = yield* Auth;
+        const authenticated = yield* auth.isAuthenticated();
+        if (!authenticated) {
+          return { user: null, isAuthenticated: false };
+        }
+        const currentUser = yield* auth.getUser();
+        return { user: currentUser, isAuthenticated: true };
+      }).pipe(Effect6.provide(AuthLive))
+    ),
+    staleTime: Infinity
+  });
+  const { data: tokenInfoData } = useQuery3({
+    queryKey: ["tokenInfo"],
+    queryFn: () => Effect6.runPromise(
+      Effect6.gen(function* () {
+        const auth = yield* Auth;
+        return yield* auth.getTokenInfo();
+      }).pipe(Effect6.provide(AuthLive))
+    ),
+    staleTime: 0
+    // Always refetch
+  });
+  const { data: availableSourcesData } = useQuery3({
+    queryKey: ["availableSources"],
+    queryFn: () => Effect6.runPromise(
+      Effect6.gen(function* () {
+        const auth = yield* Auth;
+        return yield* auth.getAvailableSources();
+      }).pipe(Effect6.provide(AuthLive))
+    ),
+    staleTime: 0
+  });
+  const saveTokenMutation = useMutation2({
+    mutationFn: async (token) => {
+      await Effect6.runPromise(
+        Effect6.gen(function* () {
+          const auth = yield* Auth;
+          yield* auth.setToken(token);
+        }).pipe(Effect6.provide(AuthLive))
+      );
+    },
+    onSuccess: () => {
+      queryClient2.invalidateQueries({ queryKey: ["auth"] });
+      queryClient2.invalidateQueries({ queryKey: ["tokenInfo"] });
+      queryClient2.invalidateQueries({ queryKey: ["availableSources"] });
+    }
+  });
+  const setPreferredSourceMutation = useMutation2({
+    mutationFn: async (source) => {
+      await Effect6.runPromise(
+        Effect6.gen(function* () {
+          const auth = yield* Auth;
+          yield* auth.setPreferredSource(source);
+        }).pipe(Effect6.provide(AuthLive))
+      );
+    },
+    onSuccess: () => {
+      queryClient2.invalidateQueries({ queryKey: ["auth"] });
+      queryClient2.invalidateQueries({ queryKey: ["tokenInfo"] });
+    }
+  });
+  const clearManualTokenMutation = useMutation2({
+    mutationFn: async () => {
+      await Effect6.runPromise(
+        Effect6.gen(function* () {
+          const auth = yield* Auth;
+          yield* auth.clearManualToken();
+        }).pipe(Effect6.provide(AuthLive))
+      );
+    },
+    onSuccess: () => {
+      queryClient2.invalidateQueries({ queryKey: ["auth"] });
+      queryClient2.invalidateQueries({ queryKey: ["tokenInfo"] });
+      queryClient2.invalidateQueries({ queryKey: ["availableSources"] });
+    }
+  });
+  return {
+    user: data?.user ?? null,
+    isAuthenticated: data?.isAuthenticated ?? false,
+    error: error ? String(error) : null,
+    loading: isLoading,
+    saveToken: saveTokenMutation.mutateAsync,
+    isSavingToken: saveTokenMutation.isPending,
+    tokenInfo: tokenInfoData ?? null,
+    availableSources: availableSourcesData ?? [],
+    setPreferredSource: setPreferredSourceMutation.mutateAsync,
+    clearManualToken: clearManualTokenMutation.mutateAsync,
+    refetch: () => {
+      refetch();
+      queryClient2.invalidateQueries({ queryKey: ["tokenInfo"] });
+      queryClient2.invalidateQueries({ queryKey: ["availableSources"] });
+    }
+  };
+}
+
+// src/screens/SettingsScreen.tsx
+import { jsx as jsx23, jsxs as jsxs20 } from "react/jsx-runtime";
+function SettingRow({
+  label,
+  value,
+  isSelected,
+  isEditing
+}) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs20(Box23, { gap: 2, paddingX: 2, children: [
+    /* @__PURE__ */ jsx23(Box23, { width: 20, children: /* @__PURE__ */ jsxs20(
+      Text20,
+      {
+        color: isSelected ? theme.colors.accent : theme.colors.muted,
+        bold: isSelected,
+        children: [
+          isSelected ? "> " : "  ",
+          label
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx23(
+      Text20,
+      {
+        color: isEditing ? theme.colors.accent : theme.colors.text,
+        inverse: isEditing,
+        children: value
+      }
+    )
+  ] });
+}
+function TokenSourceLabel({ source }) {
+  const theme = useTheme();
+  const labels = {
+    manual: { text: "Manual Token", color: theme.colors.warning },
+    env: { text: "Environment Variable", color: theme.colors.success },
+    gh_cli: { text: "GitHub CLI (gh)", color: theme.colors.info },
+    none: { text: "Not configured", color: theme.colors.error }
+  };
+  const { text, color } = labels[source];
+  return /* @__PURE__ */ jsx23(Text20, { color, children: text });
+}
+function SettingsScreen() {
+  const theme = useTheme();
+  const { config, loading: configLoading, error: configError } = useConfig();
+  const {
+    tokenInfo,
+    availableSources,
+    setPreferredSource,
+    saveToken,
+    loading: authLoading
+  } = useAuth();
+  const [selectedItem, setSelectedItem] = useState12("token_source");
+  const [isEditingToken, setIsEditingToken] = useState12(false);
+  const [newTokenValue, setNewTokenValue] = useState12("");
+  const [tokenMessage, setTokenMessage] = useState12(null);
+  const settingsItems = ["token_source", "new_token", "theme", "page_size"];
+  useInput9(
+    (input, key) => {
+      if (isEditingToken) {
+        if (key.escape) {
+          setIsEditingToken(false);
+          setNewTokenValue("");
+        } else if (key.return && newTokenValue.trim()) {
+          saveToken(newTokenValue.trim()).then(() => {
+            setTokenMessage("Token saved successfully!");
+            setIsEditingToken(false);
+            setNewTokenValue("");
+            setTimeout(() => setTokenMessage(null), 3e3);
+          }).catch((err) => {
+            setTokenMessage(`Error: ${String(err)}`);
+          });
+        }
+        return;
+      }
+      if (input === "j" || key.downArrow) {
+        const currentIndex = settingsItems.indexOf(selectedItem);
+        const nextIndex = Math.min(currentIndex + 1, settingsItems.length - 1);
+        setSelectedItem(settingsItems[nextIndex]);
+      } else if (input === "k" || key.upArrow) {
+        const currentIndex = settingsItems.indexOf(selectedItem);
+        const prevIndex = Math.max(currentIndex - 1, 0);
+        setSelectedItem(settingsItems[prevIndex]);
+      } else if (key.return) {
+        if (selectedItem === "token_source") {
+          const currentSource = tokenInfo?.source ?? "none";
+          const sourceOrder = ["gh_cli", "env", "manual"];
+          const availableInOrder = sourceOrder.filter((s) => availableSources.includes(s));
+          if (availableInOrder.length > 0) {
+            const currentIndex = availableInOrder.indexOf(currentSource);
+            const nextIndex = (currentIndex + 1) % availableInOrder.length;
+            setPreferredSource(availableInOrder[nextIndex]);
+          }
+        } else if (selectedItem === "new_token") {
+          setIsEditingToken(true);
+        }
+      }
+    },
+    { isActive: true }
+  );
+  if (configLoading || authLoading) {
+    return /* @__PURE__ */ jsx23(LoadingIndicator, { message: "Loading settings..." });
+  }
+  if (configError) {
+    return /* @__PURE__ */ jsx23(Box23, { padding: 1, children: /* @__PURE__ */ jsxs20(Text20, { color: theme.colors.error, children: [
+      "Error: ",
+      configError
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs20(Box23, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx23(Box23, { paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsx23(Text20, { color: theme.colors.accent, bold: true, children: "Settings" }) }),
+    /* @__PURE__ */ jsx23(Box23, { paddingX: 1, children: /* @__PURE__ */ jsx23(Divider, {}) }),
+    /* @__PURE__ */ jsx23(Box23, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: /* @__PURE__ */ jsx23(Text20, { color: theme.colors.secondary, bold: true, children: "Authentication" }) }),
+    /* @__PURE__ */ jsxs20(Box23, { flexDirection: "column", gap: 0, children: [
+      /* @__PURE__ */ jsxs20(Box23, { gap: 2, paddingX: 2, children: [
+        /* @__PURE__ */ jsx23(Box23, { width: 20, children: /* @__PURE__ */ jsxs20(
+          Text20,
+          {
+            color: selectedItem === "token_source" ? theme.colors.accent : theme.colors.muted,
+            bold: selectedItem === "token_source",
+            children: [
+              selectedItem === "token_source" ? "> " : "  ",
+              "Token Source"
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsx23(TokenSourceLabel, { source: tokenInfo?.source ?? "none" }),
+        availableSources.length > 1 && selectedItem === "token_source" && /* @__PURE__ */ jsx23(Text20, { color: theme.colors.muted, dimColor: true, children: "(Enter to switch)" })
+      ] }),
+      /* @__PURE__ */ jsxs20(Box23, { gap: 2, paddingX: 2, children: [
+        /* @__PURE__ */ jsx23(Box23, { width: 20, children: /* @__PURE__ */ jsx23(Text20, { color: theme.colors.muted, children: "  Token" }) }),
+        /* @__PURE__ */ jsx23(Text20, { color: theme.colors.text, children: tokenInfo?.maskedToken ?? "(none)" })
+      ] }),
+      /* @__PURE__ */ jsxs20(Box23, { gap: 2, paddingX: 2, children: [
+        /* @__PURE__ */ jsx23(Box23, { width: 20, children: /* @__PURE__ */ jsx23(Text20, { color: theme.colors.muted, children: "  Available" }) }),
+        /* @__PURE__ */ jsx23(Text20, { color: theme.colors.muted, children: availableSources.length > 0 ? availableSources.join(", ") : "none" })
+      ] }),
+      /* @__PURE__ */ jsxs20(Box23, { gap: 2, paddingX: 2, marginTop: 1, children: [
+        /* @__PURE__ */ jsx23(Box23, { width: 20, children: /* @__PURE__ */ jsxs20(
+          Text20,
+          {
+            color: selectedItem === "new_token" ? theme.colors.accent : theme.colors.muted,
+            bold: selectedItem === "new_token",
+            children: [
+              selectedItem === "new_token" ? "> " : "  ",
+              "Set New Token"
+            ]
+          }
+        ) }),
+        isEditingToken ? /* @__PURE__ */ jsx23(Box23, { borderStyle: "single", borderColor: theme.colors.accent, paddingX: 1, width: 40, children: /* @__PURE__ */ jsx23(
+          TextInput3,
+          {
+            defaultValue: newTokenValue,
+            onChange: setNewTokenValue,
+            placeholder: "ghp_xxxx..."
+          }
+        ) }) : /* @__PURE__ */ jsx23(Text20, { color: theme.colors.muted, dimColor: true, children: "(Enter to add)" })
+      ] }),
+      tokenMessage && /* @__PURE__ */ jsx23(Box23, { paddingX: 4, marginTop: 1, children: /* @__PURE__ */ jsx23(
+        Text20,
+        {
+          color: tokenMessage.startsWith("Error") ? theme.colors.error : theme.colors.success,
+          children: tokenMessage
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx23(Box23, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx23(Divider, { title: "Configuration" }) }),
+    /* @__PURE__ */ jsx23(Box23, { flexDirection: "column", paddingX: 1, marginTop: 0, marginBottom: 1, children: /* @__PURE__ */ jsx23(Text20, { color: theme.colors.secondary, bold: true, children: "Configuration" }) }),
+    /* @__PURE__ */ jsxs20(Box23, { flexDirection: "column", gap: 0, children: [
+      /* @__PURE__ */ jsx23(
+        SettingRow,
+        {
+          label: "Theme",
+          value: config?.theme ?? "tokyo-night",
+          isSelected: selectedItem === "theme"
+        }
+      ),
+      /* @__PURE__ */ jsx23(
+        SettingRow,
+        {
+          label: "Page Size",
+          value: String(config?.pageSize ?? 30),
+          isSelected: selectedItem === "page_size"
+        }
+      ),
+      /* @__PURE__ */ jsx23(
+        SettingRow,
+        {
+          label: "Provider",
+          value: config?.provider ?? "github"
+        }
+      ),
+      /* @__PURE__ */ jsx23(
+        SettingRow,
+        {
+          label: "Default Owner",
+          value: config?.defaultOwner ?? "(not set)"
+        }
+      ),
+      /* @__PURE__ */ jsx23(
+        SettingRow,
+        {
+          label: "Default Repo",
+          value: config?.defaultRepo ?? "(not set)"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs20(Box23, { paddingX: 1, paddingTop: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx23(Text20, { color: theme.colors.muted, dimColor: true, children: "Config: ~/.config/lazyreview/config.yaml" }),
+      /* @__PURE__ */ jsx23(Text20, { color: theme.colors.muted, dimColor: true, children: "Token: ~/.config/lazyreview/.token" })
+    ] }),
+    /* @__PURE__ */ jsx23(Box23, { paddingX: 1, paddingTop: 1, children: /* @__PURE__ */ jsx23(Text20, { color: theme.colors.muted, dimColor: true, children: "j/k: navigate | Enter: select/toggle | Esc: cancel" }) })
+  ] });
+}
+
+// src/screens/InvolvedScreen.tsx
+import { useState as useState13 } from "react";
+import { Box as Box24, Text as Text21, useInput as useInput10 } from "ink";
+import { jsx as jsx24, jsxs as jsxs21 } from "react/jsx-runtime";
+function InvolvedScreen({
+  onSelect
+}) {
+  const theme = useTheme();
+  const { data: prs = [], isLoading, error } = useInvolvedPRs();
+  const [showFilter, setShowFilter] = useState13(false);
+  const [showSort, setShowSort] = useState13(false);
+  const {
+    filter,
+    filteredItems,
+    setSearch,
+    setRepo,
+    setAuthor,
+    setLabel,
+    setSortBy,
+    toggleSortDirection,
+    clearFilters,
+    hasActiveFilters,
+    availableRepos,
+    availableAuthors,
+    availableLabels
+  } = useFilter(prs);
+  const {
+    currentPage,
+    totalPages,
+    pageItems,
+    hasNextPage,
+    hasPrevPage,
+    nextPage,
+    prevPage,
+    startIndex,
+    endIndex
+  } = usePagination(filteredItems, { pageSize: 18 });
+  const { selectedIndex } = useListNavigation({
+    itemCount: pageItems.length,
+    viewportHeight: pageItems.length,
+    isActive: !showFilter && !showSort
+  });
+  useInput10(
+    (input, key) => {
+      if (key.return && pageItems[selectedIndex]) {
+        onSelect(pageItems[selectedIndex]);
+      } else if (input === "n" && hasNextPage) {
+        nextPage();
+      } else if (input === "p" && hasPrevPage) {
+        prevPage();
+      } else if (input === "/") {
+        setShowFilter(true);
+      } else if (input === "s") {
+        setShowSort(true);
+      }
+    },
+    { isActive: !showFilter && !showSort }
+  );
+  if (isLoading && prs.length === 0) {
+    return /* @__PURE__ */ jsx24(LoadingIndicator, { message: "Loading involved PRs..." });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx24(Box24, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs21(Text21, { color: theme.colors.error, children: [
+      "Error: ",
+      String(error)
+    ] }) });
+  }
+  if (prs.length === 0) {
+    return /* @__PURE__ */ jsx24(EmptyState, { message: "No pull requests you're involved in" });
+  }
+  return /* @__PURE__ */ jsxs21(Box24, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs21(Box24, { paddingX: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs21(Box24, { gap: 2, children: [
+        /* @__PURE__ */ jsx24(Text21, { color: theme.colors.accent, bold: true, children: "Involved Pull Requests" }),
+        hasActiveFilters && /* @__PURE__ */ jsx24(Text21, { color: theme.colors.warning, children: "(filtered)" }),
+        /* @__PURE__ */ jsx24(Text21, { color: theme.colors.muted, children: "/ filter s sort" })
+      ] }),
+      /* @__PURE__ */ jsx24(
+        PaginationBar,
+        {
+          currentPage,
+          totalPages,
+          totalItems: filteredItems.length,
+          startIndex,
+          endIndex,
+          hasNextPage,
+          hasPrevPage
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx24(Box24, { flexDirection: "column", children: pageItems.length === 0 ? /* @__PURE__ */ jsx24(Box24, { padding: 1, children: /* @__PURE__ */ jsx24(Text21, { color: theme.colors.muted, children: "No PRs match the current filters" }) }) : pageItems.map((pr, index) => /* @__PURE__ */ jsx24(
+      PRListItem,
+      {
+        item: pr,
+        isFocus: index === selectedIndex
+      },
+      pr.id
+    )) }),
+    showFilter && /* @__PURE__ */ jsx24(
+      FilterModal,
+      {
+        filter,
+        availableRepos,
+        availableAuthors,
+        availableLabels,
+        onSearchChange: setSearch,
+        onRepoChange: setRepo,
+        onAuthorChange: setAuthor,
+        onLabelChange: setLabel,
+        onSortChange: setSortBy,
+        onSortDirectionToggle: toggleSortDirection,
+        onClear: clearFilters,
+        onClose: () => setShowFilter(false)
+      }
+    ),
+    showSort && /* @__PURE__ */ jsx24(
+      SortModal,
+      {
+        currentSort: filter.sortBy,
+        sortDirection: filter.sortDirection,
+        onSortChange: setSortBy,
+        onSortDirectionToggle: toggleSortDirection,
+        onClose: () => setShowSort(false)
+      }
+    )
+  ] });
+}
+
+// src/screens/ThisRepoScreen.tsx
+import { useState as useState14 } from "react";
+import { Box as Box25, Text as Text22, useInput as useInput11 } from "ink";
+import { jsx as jsx25, jsxs as jsxs22 } from "react/jsx-runtime";
+function ThisRepoScreen({
+  owner,
+  repo,
+  onSelect
+}) {
+  const theme = useTheme();
+  const {
+    data: prs = [],
+    isLoading,
+    error
+  } = usePullRequests(owner ?? "", repo ?? "", { state: "open" });
+  const [showFilter, setShowFilter] = useState14(false);
+  const [showSort, setShowSort] = useState14(false);
+  const {
+    filter,
+    filteredItems,
+    setSearch,
+    setRepo: setRepoFilter,
+    setAuthor,
+    setLabel,
+    setSortBy,
+    toggleSortDirection,
+    clearFilters,
+    hasActiveFilters,
+    availableRepos,
+    availableAuthors,
+    availableLabels
+  } = useFilter(prs);
+  const {
+    currentPage,
+    totalPages,
+    pageItems,
+    hasNextPage,
+    hasPrevPage,
+    nextPage,
+    prevPage,
+    startIndex,
+    endIndex
+  } = usePagination(filteredItems, { pageSize: 18 });
+  const { selectedIndex } = useListNavigation({
+    itemCount: pageItems.length,
+    viewportHeight: pageItems.length,
+    isActive: !showFilter && !showSort
+  });
+  useInput11(
+    (input, key) => {
+      if (key.return && pageItems[selectedIndex]) {
+        onSelect(pageItems[selectedIndex]);
+      } else if (input === "n" && hasNextPage) {
+        nextPage();
+      } else if (input === "p" && hasPrevPage) {
+        prevPage();
+      } else if (input === "/") {
+        setShowFilter(true);
+      } else if (input === "s") {
+        setShowSort(true);
+      }
+    },
+    { isActive: !showFilter && !showSort }
+  );
+  if (!owner || !repo) {
+    return /* @__PURE__ */ jsx25(EmptyState, { message: "Not in a git repository or remote not detected" });
+  }
+  if (isLoading && prs.length === 0) {
+    return /* @__PURE__ */ jsx25(LoadingIndicator, { message: `Loading PRs for ${owner}/${repo}...` });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx25(Box25, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs22(Text22, { color: theme.colors.error, children: [
+      "Error: ",
+      String(error)
+    ] }) });
+  }
+  if (prs.length === 0) {
+    return /* @__PURE__ */ jsx25(EmptyState, { message: `No open PRs in ${owner}/${repo}` });
+  }
+  return /* @__PURE__ */ jsxs22(Box25, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs22(Box25, { paddingX: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs22(Box25, { gap: 2, children: [
+        /* @__PURE__ */ jsxs22(Text22, { color: theme.colors.accent, bold: true, children: [
+          owner,
+          "/",
+          repo
+        ] }),
+        hasActiveFilters && /* @__PURE__ */ jsx25(Text22, { color: theme.colors.warning, children: "(filtered)" }),
+        /* @__PURE__ */ jsx25(Text22, { color: theme.colors.muted, children: "/ filter s sort" })
+      ] }),
+      /* @__PURE__ */ jsx25(
+        PaginationBar,
+        {
+          currentPage,
+          totalPages,
+          totalItems: filteredItems.length,
+          startIndex,
+          endIndex,
+          hasNextPage,
+          hasPrevPage
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx25(Box25, { flexDirection: "column", children: pageItems.length === 0 ? /* @__PURE__ */ jsx25(Box25, { padding: 1, children: /* @__PURE__ */ jsx25(Text22, { color: theme.colors.muted, children: "No PRs match the current filters" }) }) : pageItems.map((pr, index) => /* @__PURE__ */ jsx25(
+      PRListItem,
+      {
+        item: pr,
+        isFocus: index === selectedIndex
+      },
+      pr.id
+    )) }),
+    showFilter && /* @__PURE__ */ jsx25(
+      FilterModal,
+      {
+        filter,
+        availableRepos,
+        availableAuthors,
+        availableLabels,
+        onSearchChange: setSearch,
+        onRepoChange: setRepoFilter,
+        onAuthorChange: setAuthor,
+        onLabelChange: setLabel,
+        onSortChange: setSortBy,
+        onSortDirectionToggle: toggleSortDirection,
+        onClear: clearFilters,
+        onClose: () => setShowFilter(false)
+      }
+    ),
+    showSort && /* @__PURE__ */ jsx25(
+      SortModal,
+      {
+        currentSort: filter.sortBy,
+        sortDirection: filter.sortDirection,
+        onSortChange: setSortBy,
+        onSortDirectionToggle: toggleSortDirection,
+        onClose: () => setShowSort(false)
+      }
+    )
+  ] });
+}
+
+// src/app.tsx
+import { Match as Match3 } from "effect";
+
+// src/hooks/useActivePanel.ts
+import { useInput as useInput12 } from "ink";
+import { useCallback as useCallback5, useEffect as useEffect9, useState as useState15 } from "react";
+function useActivePanel({
+  hasSelection
+}) {
+  const [activePanel, setActivePanel] = useState15("sidebar");
+  useEffect9(() => {
+    if (!hasSelection && activePanel === "detail") {
+      setActivePanel("list");
+    }
+  }, [hasSelection, activePanel]);
+  const handleEscape = useCallback5(() => {
+    if (activePanel === "detail") {
+      setActivePanel("list");
+    } else if (activePanel === "list") {
+      setActivePanel("sidebar");
+    }
+  }, [activePanel]);
+  const handleTab = useCallback5(() => {
+    if (activePanel === "sidebar") {
+      setActivePanel("list");
+    } else if (activePanel === "list" && hasSelection) {
+      setActivePanel("detail");
+    } else if (activePanel === "detail") {
+      setActivePanel("sidebar");
+    }
+  }, [activePanel, hasSelection]);
+  useInput12((_input, key) => {
+    if (key.escape) {
+      handleEscape();
+    } else if (key.tab) {
+      handleTab();
+    }
+  });
+  return { activePanel, setActivePanel };
+}
+
+// src/app.tsx
+import { jsx as jsx26, jsxs as jsxs23 } from "react/jsx-runtime";
+function AppContent({
+  repoOwner,
+  repoName
+}) {
+  const { exit } = useApp();
+  const { stdout } = useStdout8();
+  const { user, isAuthenticated, loading, saveToken, error } = useAuth();
+  const [sidebarVisible, setSidebarVisible] = useState16(true);
+  const [currentScreen, setCurrentScreen] = useState16({
+    type: "list"
+  });
+  const [tokenError, setTokenError] = useState16(null);
+  const [showHelp, setShowHelp] = useState16(false);
+  const [showTokenInput, setShowTokenInput] = useState16(false);
+  const { activePanel, setActivePanel } = useActivePanel({
+    hasSelection: currentScreen.type === "detail"
+  });
+  const { isInputActive } = useInputFocus();
+  const { selectedIndex: sidebarIndex } = useListNavigation({
+    itemCount: SIDEBAR_ITEMS.length,
+    viewportHeight: SIDEBAR_ITEMS.length,
+    isActive: activePanel === "sidebar" && !showHelp && !showTokenInput
+  });
+  React16.useEffect(() => {
+    if (!loading && !isAuthenticated && !showTokenInput) {
+      setShowTokenInput(true);
+    } else if (isAuthenticated && showTokenInput) {
+      setShowTokenInput(false);
+    }
+  }, [loading, isAuthenticated, showTokenInput]);
+  const handleTokenSubmit = useCallback6(
+    async (token) => {
+      try {
+        setTokenError(null);
+        await saveToken(token);
+      } catch (err) {
+        setTokenError(String(err));
+      }
+    },
+    [saveToken]
+  );
+  useInput13(
+    (input, key) => {
+      if (showHelp || showTokenInput) {
+        if (key.escape || showHelp && input === "?") {
+          setShowHelp(false);
+        }
+        return;
+      }
+      if (input === "b") {
+        setSidebarVisible((prev) => !prev);
+      } else if (input === "?") {
+        setShowHelp(true);
+      } else if (input === "q") {
+        if (currentScreen.type === "detail") {
+          setCurrentScreen({ type: "list" });
+        } else {
+          exit();
+        }
+      } else if (key.return && activePanel === "sidebar") {
+        setActivePanel("list");
+      }
+    },
+    { isActive: !showTokenInput && !isInputActive }
+  );
+  const handleSelectPR = useCallback6((pr) => {
+    setCurrentScreen({ type: "detail", pr });
+  }, []);
+  const handleBackToList = useCallback6(() => {
+    setCurrentScreen({ type: "list" });
+  }, []);
+  function renderScreen() {
+    if (currentScreen.type === "detail") {
+      const prUrl = currentScreen.pr.html_url;
+      const match = prUrl.match(/github\.com\/([^/]+)\/([^/]+)\/pull/);
+      const prOwner = match?.[1] ?? repoOwner ?? "";
+      const prRepo = match?.[2] ?? repoName ?? "";
+      return /* @__PURE__ */ jsx26(
+        PRDetailScreen,
+        {
+          pr: currentScreen.pr,
+          owner: prOwner,
+          repo: prRepo,
+          onBack: handleBackToList
+        }
+      );
+    }
+    return Match3.value(sidebarIndex).pipe(
+      Match3.when(0, () => /* @__PURE__ */ jsx26(InvolvedScreen, { onSelect: handleSelectPR })),
+      Match3.when(1, () => /* @__PURE__ */ jsx26(MyPRsScreen, { onSelect: handleSelectPR })),
+      Match3.when(2, () => /* @__PURE__ */ jsx26(ReviewRequestsScreen, { onSelect: handleSelectPR })),
+      Match3.when(3, () => /* @__PURE__ */ jsx26(
+        ThisRepoScreen,
+        {
+          owner: repoOwner,
+          repo: repoName,
+          onSelect: handleSelectPR
+        }
+      )),
+      Match3.when(4, () => /* @__PURE__ */ jsx26(SettingsScreen, {})),
+      Match3.orElse(() => /* @__PURE__ */ jsx26(InvolvedScreen, { onSelect: handleSelectPR }))
+    );
+  }
+  const terminalHeight = stdout?.rows ?? 24;
+  const repoPath = repoOwner && repoName ? `${repoOwner}/${repoName}` : void 0;
+  return /* @__PURE__ */ jsxs23(Box26, { flexDirection: "column", height: terminalHeight, children: [
+    /* @__PURE__ */ jsx26(
+      TopBar,
+      {
+        username: user?.login ?? "anonymous",
+        provider: "github",
+        repoPath
+      }
+    ),
+    /* @__PURE__ */ jsxs23(Box26, { flexDirection: "row", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx26(
+        Sidebar,
+        {
+          selectedIndex: sidebarIndex,
+          visible: sidebarVisible,
+          isActive: activePanel === "sidebar"
+        }
+      ),
+      /* @__PURE__ */ jsx26(MainPanel, { isActive: activePanel === "list", children: renderScreen() })
+    ] }),
+    /* @__PURE__ */ jsx26(StatusBar, { activePanel }),
+    showHelp && /* @__PURE__ */ jsx26(HelpModal, { onClose: () => setShowHelp(false) }),
+    showTokenInput && /* @__PURE__ */ jsx26(
+      TokenInputModal,
+      {
+        onSubmit: handleTokenSubmit,
+        onClose: () => setShowTokenInput(false),
+        error: tokenError ?? error
+      }
+    )
+  ] });
+}
+var queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 1e3 * 60,
+      // 1 minute
+      retry: 1
+    }
+  }
+});
+function AppWithTheme({
+  repoOwner,
+  repoName
+}) {
+  const { config } = useConfig();
+  const themeName = config?.theme ?? "tokyo-night";
+  const theme = getThemeByName(themeName);
+  return /* @__PURE__ */ jsx26(ThemeProvider, { theme, children: /* @__PURE__ */ jsx26(AppContent, { repoOwner, repoName }) });
+}
+function App({ repoOwner, repoName }) {
+  return /* @__PURE__ */ jsx26(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx26(InputFocusProvider, { children: /* @__PURE__ */ jsx26(AppWithTheme, { repoOwner, repoName }) }) });
+}
+
+// src/utils/git.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function detectGitRepo() {
+  try {
+    await execFileAsync2("git", ["rev-parse", "--git-dir"]);
+    const { stdout } = await execFileAsync2("git", [
+      "remote",
+      "get-url",
+      "origin"
+    ]);
+    const remoteUrl = stdout.trim();
+    const parsed = parseGitHubUrl(remoteUrl);
+    return {
+      isGitRepo: true,
+      owner: parsed?.owner ?? null,
+      repo: parsed?.repo ?? null,
+      remoteUrl
+    };
+  } catch {
+    return {
+      isGitRepo: false,
+      owner: null,
+      repo: null,
+      remoteUrl: null
+    };
+  }
+}
+function parseGitHubUrl(url) {
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/([^/.]+)(?:\.git)?/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+  const httpsMatch = url.match(
+    /https?:\/\/github\.com\/([^/]+)\/([^/.]+)(?:\.git)?/
+  );
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  return null;
+}
+
+// src/cli.tsx
+import { jsx as jsx27 } from "react/jsx-runtime";
+var ENTER_ALT_SCREEN = "\x1B[?1049h";
+var EXIT_ALT_SCREEN = "\x1B[?1049l";
+var CLEAR_SCREEN = "\x1B[2J";
+var CURSOR_HOME = "\x1B[H";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+function parseArgs(argv) {
+  const repoArg = argv[2];
+  if (repoArg && repoArg.includes("/")) {
+    const [owner, repo] = repoArg.split("/");
+    if (owner && repo) {
+      return { owner, repo };
+    }
+  }
+  return null;
+}
+function cleanup() {
+  process.stdout.write(SHOW_CURSOR + EXIT_ALT_SCREEN);
+}
+async function main() {
+  process.stdout.write(
+    ENTER_ALT_SCREEN + CLEAR_SCREEN + CURSOR_HOME + HIDE_CURSOR
+  );
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  const argsRepo = parseArgs(process.argv);
+  let repoOwner = null;
+  let repoName = null;
+  if (argsRepo) {
+    repoOwner = argsRepo.owner;
+    repoName = argsRepo.repo;
+  } else {
+    const gitInfo = await detectGitRepo();
+    if (gitInfo.isGitRepo && gitInfo.owner && gitInfo.repo) {
+      repoOwner = gitInfo.owner;
+      repoName = gitInfo.repo;
+    }
+  }
+  render(/* @__PURE__ */ jsx27(App, { repoOwner, repoName }));
+}
+main().catch((error) => {
+  cleanup();
+  console.error("Failed to start:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map