lazyreview 0.1.4

package/src/hooks/useGitHub.ts

@@ -0,0 +1,260 @@
+import { useQuery } from '@tanstack/react-query'
+import { Effect } from 'effect'
+import { GitHubApi, type ListPRsOptions } from '../services/GitHubApi'
+import { AppLayer } from '../services/index'
+import type { PullRequest } from '../models/pull-request'
+import type { FileChange } from '../models/file-change'
+import type { Comment } from '../models/comment'
+import type { Review } from '../models/review'
+import type { Commit } from '../models/commit'
+
+function runEffect<A>(
+  effect: Effect.Effect<A, unknown, unknown>,
+): Promise<A> {
+  return Effect.runPromise(
+    effect.pipe(Effect.provide(AppLayer)) as Effect.Effect<A, never, never>,
+  )
+}
+
+export function usePullRequests(
+  owner: string,
+  repo: string,
+  options?: ListPRsOptions,
+) {
+  return useQuery({
+    queryKey: ['prs', owner, repo, options],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.listPullRequests(owner, repo, options)
+        }),
+      ),
+    enabled: !!owner && !!repo,
+  })
+}
+
+export function usePullRequest(owner: string, repo: string, number: number) {
+  return useQuery({
+    queryKey: ['pr', owner, repo, number],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getPullRequest(owner, repo, number)
+        }),
+      ),
+    enabled: !!owner && !!repo && !!number,
+  })
+}
+
+export function usePRFiles(owner: string, repo: string, number: number) {
+  return useQuery({
+    queryKey: ['pr-files', owner, repo, number],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getPullRequestFiles(owner, repo, number)
+        }),
+      ),
+    enabled: !!owner && !!repo && !!number,
+  })
+}
+
+export function usePRComments(owner: string, repo: string, number: number) {
+  return useQuery({
+    queryKey: ['pr-comments', owner, repo, number],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getPullRequestComments(owner, repo, number)
+        }),
+      ),
+    enabled: !!owner && !!repo && !!number,
+  })
+}
+
+export function usePRReviews(owner: string, repo: string, number: number) {
+  return useQuery({
+    queryKey: ['pr-reviews', owner, repo, number],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getPullRequestReviews(owner, repo, number)
+        }),
+      ),
+    enabled: !!owner && !!repo && !!number,
+  })
+}
+
+export function usePRCommits(owner: string, repo: string, number: number) {
+  return useQuery({
+    queryKey: ['pr-commits', owner, repo, number],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getPullRequestCommits(owner, repo, number)
+        }),
+      ),
+    enabled: !!owner && !!repo && !!number,
+  })
+}
+
+export function useMyPRs() {
+  return useQuery({
+    queryKey: ['my-prs'],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getMyPRs()
+        }),
+      ),
+  })
+}
+
+export function useReviewRequests() {
+  return useQuery({
+    queryKey: ['review-requests'],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getReviewRequests()
+        }),
+      ),
+  })
+}
+
+export function useInvolvedPRs() {
+  return useQuery({
+    queryKey: ['involved-prs'],
+    queryFn: () =>
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getInvolvedPRs()
+        }),
+      ),
+  })
+}
+
+// Legacy hook for backwards compatibility during migration
+interface UseGitHubReturn {
+  readonly prs: readonly PullRequest[]
+  readonly loading: boolean
+  readonly error: string | null
+  readonly fetchPRs: (
+    owner: string,
+    repo: string,
+    options?: ListPRsOptions,
+  ) => void
+  readonly fetchPR: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Promise<PullRequest | null>
+  readonly fetchFiles: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Promise<readonly FileChange[]>
+  readonly fetchComments: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Promise<readonly Comment[]>
+  readonly fetchReviews: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Promise<readonly Review[]>
+  readonly fetchMyPRs: () => void
+  readonly fetchReviewRequests: () => void
+}
+
+export function useGitHub(): UseGitHubReturn {
+  const { data: prs = [], isLoading, error } = usePullRequests('', '')
+
+  return {
+    prs,
+    loading: isLoading,
+    error: error ? String(error) : null,
+    fetchPRs: (owner, repo, options) => {
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.listPullRequests(owner, repo, options)
+        }),
+      )
+    },
+    fetchPR: async (owner, repo, number) => {
+      try {
+        return await runEffect(
+          Effect.gen(function* () {
+            const api = yield* GitHubApi
+            return yield* api.getPullRequest(owner, repo, number)
+          }),
+        )
+      } catch {
+        return null
+      }
+    },
+    fetchFiles: async (owner, repo, number) => {
+      try {
+        return await runEffect(
+          Effect.gen(function* () {
+            const api = yield* GitHubApi
+            return yield* api.getPullRequestFiles(owner, repo, number)
+          }),
+        )
+      } catch {
+        return []
+      }
+    },
+    fetchComments: async (owner, repo, number) => {
+      try {
+        return await runEffect(
+          Effect.gen(function* () {
+            const api = yield* GitHubApi
+            return yield* api.getPullRequestComments(owner, repo, number)
+          }),
+        )
+      } catch {
+        return []
+      }
+    },
+    fetchReviews: async (owner, repo, number) => {
+      try {
+        return await runEffect(
+          Effect.gen(function* () {
+            const api = yield* GitHubApi
+            return yield* api.getPullRequestReviews(owner, repo, number)
+          }),
+        )
+      } catch {
+        return []
+      }
+    },
+    fetchMyPRs: () => {
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getMyPRs()
+        }),
+      )
+    },
+    fetchReviewRequests: () => {
+      runEffect(
+        Effect.gen(function* () {
+          const api = yield* GitHubApi
+          return yield* api.getReviewRequests()
+        }),
+      )
+    },
+  }
+}

package/src/hooks/useInputFocus.tsx

@@ -0,0 +1,35 @@
+import React, { createContext, useContext, useState, useCallback } from 'react'
+
+interface InputFocusContextType {
+  readonly isInputActive: boolean
+  readonly setInputActive: (active: boolean) => void
+}
+
+const InputFocusContext = createContext<InputFocusContextType>({
+  isInputActive: false,
+  setInputActive: () => {},
+})
+
+interface InputFocusProviderProps {
+  readonly children: React.ReactNode
+}
+
+export function InputFocusProvider({
+  children,
+}: InputFocusProviderProps): React.ReactElement {
+  const [isInputActive, setIsInputActive] = useState(false)
+
+  const setInputActive = useCallback((active: boolean) => {
+    setIsInputActive(active)
+  }, [])
+
+  return React.createElement(
+    InputFocusContext.Provider,
+    { value: { isInputActive, setInputActive } },
+    children,
+  )
+}
+
+export function useInputFocus(): InputFocusContextType {
+  return useContext(InputFocusContext)
+}

package/src/hooks/useListNavigation.ts

@@ -0,0 +1,121 @@
+import { useInput } from 'ink'
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+interface UseListNavigationOptions {
+  readonly itemCount: number
+  readonly viewportHeight: number
+  readonly isActive?: boolean
+}
+
+interface UseListNavigationResult {
+  readonly selectedIndex: number
+  readonly scrollOffset: number
+  readonly setSelectedIndex: (index: number) => void
+}
+
+export function useListNavigation({
+  itemCount,
+  viewportHeight,
+  isActive = true,
+}: UseListNavigationOptions): UseListNavigationResult {
+  const [selectedIndex, setSelectedIndex] = useState(0)
+  const gPressedAt = useRef<number | null>(null)
+  const prevItemCount = useRef(itemCount)
+
+  // Auto-follow: if user was at the last item and a new one arrives, stay at bottom
+  useEffect(() => {
+    const wasAtEnd = selectedIndex === prevItemCount.current - 1
+    prevItemCount.current = itemCount
+    if (wasAtEnd && itemCount > 0) {
+      setSelectedIndex(itemCount - 1)
+    }
+  }, [itemCount, selectedIndex])
+
+  // Clamp selectedIndex if itemCount shrinks
+  useEffect(() => {
+    if (itemCount === 0) {
+      setSelectedIndex(0)
+    } else if (selectedIndex >= itemCount) {
+      setSelectedIndex(itemCount - 1)
+    }
+  }, [itemCount, selectedIndex])
+
+  const clamp = useCallback(
+    (index: number) => Math.max(0, Math.min(index, itemCount - 1)),
+    [itemCount],
+  )
+
+  useInput(
+    (input, key) => {
+      if (!isActive || itemCount === 0) return
+
+      // j / ↓ — move down
+      if (input === 'j' || key.downArrow) {
+        setSelectedIndex((i) => clamp(i + 1))
+        return
+      }
+
+      // k / ↑ — move up
+      if (input === 'k' || key.upArrow) {
+        setSelectedIndex((i) => clamp(i - 1))
+        return
+      }
+
+      // G — jump to bottom
+      if (input === 'G') {
+        setSelectedIndex(itemCount - 1)
+        return
+      }
+
+      // g — first press starts gg detection
+      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
+      }
+
+      // Ctrl+d — page down
+      if (key.ctrl && input === 'd') {
+        setSelectedIndex((i) => clamp(i + Math.floor(viewportHeight / 2)))
+        return
+      }
+
+      // Ctrl+u — page up
+      if (key.ctrl && input === 'u') {
+        setSelectedIndex((i) => clamp(i - Math.floor(viewportHeight / 2)))
+        return
+      }
+
+      // Any other key resets gg state
+      gPressedAt.current = null
+    },
+    { isActive },
+  )
+
+  // Derive scroll offset to keep selectedIndex visible
+  const scrollOffset = deriveScrollOffset(
+    selectedIndex,
+    viewportHeight,
+    itemCount,
+  )
+
+  return { selectedIndex, scrollOffset, setSelectedIndex }
+}
+
+function deriveScrollOffset(
+  selectedIndex: number,
+  viewportHeight: number,
+  itemCount: number,
+): number {
+  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
+}

package/src/hooks/useLoading.ts

@@ -0,0 +1,25 @@
+import { useSyncExternalStore } from 'react'
+import type { LoadingState, LoadingService } from '../services/Loading'
+
+let loadingService: LoadingService | null = null
+
+export function setLoadingService(service: LoadingService): void {
+  loadingService = service
+}
+
+export function getLoadingService(): LoadingService | null {
+  return loadingService
+}
+
+const emptyState: LoadingState = { isLoading: false, message: null }
+
+export function useLoading(): LoadingState {
+  return useSyncExternalStore(
+    (callback) => {
+      if (!loadingService) return () => {}
+      return loadingService.subscribe(callback)
+    },
+    () => loadingService?.getState() ?? emptyState,
+    () => emptyState,
+  )
+}

package/src/hooks/usePagination.ts

@@ -0,0 +1,87 @@
+import { useState, useMemo, useCallback, useEffect, useRef } from 'react'
+
+interface UsePaginationOptions {
+  readonly pageSize?: number
+}
+
+interface UsePaginationResult<T> {
+  readonly currentPage: number
+  readonly totalPages: number
+  readonly pageItems: readonly T[]
+  readonly hasNextPage: boolean
+  readonly hasPrevPage: boolean
+  readonly nextPage: () => void
+  readonly prevPage: () => void
+  readonly goToPage: (page: number) => void
+  readonly startIndex: number
+  readonly endIndex: number
+}
+
+export function usePagination<T>(
+  items: readonly T[],
+  options: UsePaginationOptions = {},
+): UsePaginationResult<T> {
+  const pageSize = options.pageSize ?? 18
+  const [currentPage, setCurrentPage] = useState(1)
+  const prevItemsLengthRef = useRef(items.length)
+
+  const totalPages = useMemo(
+    () => Math.max(1, Math.ceil(items.length / pageSize)),
+    [items.length, pageSize],
+  )
+
+  // Reset to page 1 when items change (e.g., filter applied)
+  useEffect(() => {
+    if (items.length !== prevItemsLengthRef.current) {
+      setCurrentPage(1)
+      prevItemsLengthRef.current = items.length
+    }
+  }, [items.length])
+
+  // Ensure current page is within bounds
+  const safePage = Math.min(currentPage, totalPages)
+
+  const startIndex = (safePage - 1) * pageSize
+  const endIndex = Math.min(startIndex + pageSize, items.length)
+
+  const pageItems = useMemo(
+    () => items.slice(startIndex, endIndex),
+    [items, startIndex, endIndex],
+  )
+
+  const hasNextPage = safePage < totalPages
+  const hasPrevPage = safePage > 1
+
+  const nextPage = useCallback(() => {
+    if (hasNextPage) {
+      setCurrentPage((p) => p + 1)
+    }
+  }, [hasNextPage])
+
+  const prevPage = useCallback(() => {
+    if (hasPrevPage) {
+      setCurrentPage((p) => p - 1)
+    }
+  }, [hasPrevPage])
+
+  const goToPage = useCallback(
+    (page: number) => {
+      const clampedPage = Math.max(1, Math.min(page, totalPages))
+      setCurrentPage(clampedPage)
+    },
+    [totalPages],
+  )
+
+  return {
+    currentPage: safePage,
+    totalPages,
+    pageItems,
+    hasNextPage,
+    hasPrevPage,
+    nextPage,
+    prevPage,
+    goToPage,
+    startIndex,
+    endIndex,
+  }
+}

package/src/models/comment.ts

@@ -0,0 +1,15 @@
+import { Schema as S } from 'effect'
+import { User } from './user'
+
+export class Comment extends S.Class<Comment>('Comment')({
+  id: S.Number,
+  body: S.String,
+  user: User,
+  created_at: S.String,
+  updated_at: S.String,
+  html_url: S.String,
+  path: S.optional(S.String),
+  line: S.optional(S.NullOr(S.Number)),
+  side: S.optional(S.Literal('LEFT', 'RIGHT')),
+  in_reply_to_id: S.optional(S.Number),
+}) {}

package/src/models/commit.ts

@@ -0,0 +1,20 @@
+import { Schema as S } from 'effect'
+import { User } from './user'
+
+export class CommitAuthor extends S.Class<CommitAuthor>('CommitAuthor')({
+  name: S.String,
+  email: S.String,
+  date: S.String,
+}) {}
+
+export class CommitDetails extends S.Class<CommitDetails>('CommitDetails')({
+  message: S.String,
+  author: CommitAuthor,
+}) {}
+
+export class Commit extends S.Class<Commit>('Commit')({
+  sha: S.String,
+  commit: CommitDetails,
+  author: S.optionalWith(S.NullOr(User), { default: () => null }),
+  html_url: S.String,
+}) {}

package/src/models/diff.ts

@@ -0,0 +1,93 @@
+export interface DiffLine {
+  readonly type: 'add' | 'del' | 'context' | 'header'
+  readonly content: string
+  readonly oldLineNumber?: number
+  readonly newLineNumber?: number
+}
+
+export interface Hunk {
+  readonly header: string
+  readonly oldStart: number
+  readonly oldCount: number
+  readonly newStart: number
+  readonly newCount: number
+  readonly lines: readonly DiffLine[]
+}
+
+export interface FileDiff {
+  readonly filename: string
+  readonly status: 'added' | 'removed' | 'modified' | 'renamed'
+  readonly additions: number
+  readonly deletions: number
+  readonly hunks: readonly Hunk[]
+  readonly previousFilename?: string
+}
+
+export interface Diff {
+  readonly files: readonly FileDiff[]
+  readonly totalAdditions: number
+  readonly totalDeletions: number
+}
+
+export function parseDiffPatch(patch: string): readonly Hunk[] {
+  const hunks: Hunk[] = []
+  const lines = patch.split('\n')
+  let currentHunk: Hunk | null = null
+  let currentLines: DiffLine[] = []
+  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
+}

package/src/models/errors.ts

@@ -0,0 +1,24 @@
+import { Data } from 'effect'
+
+export class GitHubError extends Data.TaggedError('GitHubError')<{
+  readonly message: string
+  readonly status?: number
+  readonly url?: string
+}> {}
+
+export class AuthError extends Data.TaggedError('AuthError')<{
+  readonly message: string
+  readonly reason: 'no_token' | 'invalid_token' | 'expired_token' | 'save_failed'
+}> {}
+
+export class ConfigError extends Data.TaggedError('ConfigError')<{
+  readonly message: string
+  readonly path?: string
+}> {}
+
+export class NetworkError extends Data.TaggedError('NetworkError')<{
+  readonly message: string
+  readonly cause?: unknown
+}> {}
+
+export type AppError = GitHubError | AuthError | ConfigError | NetworkError

package/src/models/file-change.ts

@@ -0,0 +1,22 @@
+import { Schema as S } from 'effect'
+
+export class FileChange extends S.Class<FileChange>('FileChange')({
+  sha: S.String,
+  filename: S.String,
+  status: S.Literal(
+    'added',
+    'removed',
+    'modified',
+    'renamed',
+    'copied',
+    'changed',
+    'unchanged',
+  ),
+  additions: S.Number,
+  deletions: S.Number,
+  changes: S.Number,
+  patch: S.optional(S.String),
+  previous_filename: S.optional(S.String),
+  blob_url: S.optional(S.String),
+  raw_url: S.optional(S.String),
+}) {}