lazyreview 0.1.4

package/src/services/Auth.ts

@@ -0,0 +1,314 @@
+import { Context, Effect, Layer, Schema as S } from 'effect'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { writeFile, readFile, mkdir, unlink } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { AuthError } from '../models/errors'
+import { User } from '../models/user'
+
+const execFileAsync = promisify(execFile)
+
+export type TokenSource = 'manual' | 'env' | 'gh_cli' | 'none'
+
+export interface TokenInfo {
+  readonly source: TokenSource
+  readonly token: string | null
+  readonly maskedToken: string | null
+}
+
+// Config directory for storing token
+const CONFIG_DIR = join(homedir(), '.config', 'lazyreview')
+const TOKEN_FILE = join(CONFIG_DIR, '.token')
+
+// In-memory token storage for current session
+let sessionToken: string | null = null
+let preferredSource: TokenSource | null = null
+
+// Load saved token from file on startup
+async function loadSavedToken(): Promise<string | null> {
+  try {
+    const token = await readFile(TOKEN_FILE, 'utf-8')
+    return token.trim() || null
+  } catch {
+    return null
+  }
+}
+
+// Save token to file for persistence
+async function saveTokenToFile(token: string): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true })
+  await writeFile(TOKEN_FILE, token, { mode: 0o600 }) // Secure permissions
+}
+
+// Delete saved token file
+async function deleteSavedToken(): Promise<void> {
+  try {
+    await unlink(TOKEN_FILE)
+  } catch {
+    // File might not exist
+  }
+}
+
+// Initialize: load saved token on module load
+let savedToken: string | null = null
+loadSavedToken().then((token) => {
+  savedToken = token
+})
+
+function maskToken(token: string): string {
+  if (token.length <= 8) return '****'
+  return `${token.slice(0, 4)}...${token.slice(-4)}`
+}
+
+async function tryGetGhToken(): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync('gh', ['auth', 'token'])
+    return stdout.trim() || null
+  } catch {
+    return null
+  }
+}
+
+export interface AuthService {
+  readonly getToken: () => Effect.Effect<string, AuthError>
+  readonly getUser: () => Effect.Effect<User, AuthError>
+  readonly isAuthenticated: () => Effect.Effect<boolean, AuthError>
+  readonly setToken: (token: string) => Effect.Effect<void, never>
+  readonly getTokenInfo: () => Effect.Effect<TokenInfo, never>
+  readonly setPreferredSource: (source: TokenSource) => Effect.Effect<void, never>
+  readonly getAvailableSources: () => Effect.Effect<TokenSource[], never>
+  readonly clearManualToken: () => Effect.Effect<void, never>
+}
+
+export class Auth extends Context.Tag('Auth')<Auth, AuthService>() {}
+
+function resolveToken(): Effect.Effect<string, AuthError> {
+  return Effect.gen(function* () {
+    // If preferred source is set, use only that source
+    if (preferredSource === 'manual') {
+      const manualToken = sessionToken ?? savedToken
+      if (manualToken) return manualToken
+      return yield* Effect.fail(
+        new AuthError({ message: 'No manual token found', reason: 'no_token' })
+      )
+    }
+
+    if (preferredSource === 'env') {
+      const envToken = process.env['LAZYREVIEW_GITHUB_TOKEN']
+      if (envToken) return envToken
+      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' })
+      )
+    }
+
+    // Default priority order:
+    // 1. LAZYREVIEW_GITHUB_TOKEN env var (highest priority)
+    const envToken = process.env['LAZYREVIEW_GITHUB_TOKEN']
+    if (envToken) return envToken
+
+    // 2. Manual/saved token (from settings or file)
+    const manualToken = sessionToken ?? savedToken
+    if (manualToken) return manualToken
+
+    // 3. gh CLI fallback
+    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
+
+    // 4. No token found - will show modal
+    return yield* Effect.fail(
+      new AuthError({
+        message: 'No GitHub token found. Set LAZYREVIEW_GITHUB_TOKEN or configure in Settings.',
+        reason: 'no_token',
+      }),
+    )
+  })
+}
+
+function resolveTokenInfo(): Effect.Effect<TokenInfo, never> {
+  return Effect.gen(function* () {
+    // Check preferred source first
+    if (preferredSource === 'manual') {
+      const manualToken = sessionToken ?? savedToken
+      if (manualToken) {
+        return {
+          source: 'manual' as TokenSource,
+          token: manualToken,
+          maskedToken: maskToken(manualToken),
+        }
+      }
+    }
+
+    if (preferredSource === 'env') {
+      const envToken = process.env['LAZYREVIEW_GITHUB_TOKEN']
+      if (envToken) {
+        return {
+          source: 'env' as TokenSource,
+          token: envToken,
+          maskedToken: maskToken(envToken),
+        }
+      }
+    }
+
+    if (preferredSource === 'gh_cli') {
+      const ghToken = yield* Effect.promise(tryGetGhToken)
+      if (ghToken) {
+        return {
+          source: 'gh_cli' as TokenSource,
+          token: ghToken,
+          maskedToken: maskToken(ghToken),
+        }
+      }
+    }
+
+    // Default: show what's currently being used (following priority order)
+    // 1. LAZYREVIEW_GITHUB_TOKEN
+    const envToken = process.env['LAZYREVIEW_GITHUB_TOKEN']
+    if (envToken) {
+      return {
+        source: 'env' as TokenSource,
+        token: envToken,
+        maskedToken: maskToken(envToken),
+      }
+    }
+
+    // 2. Manual/saved token
+    const manualToken = sessionToken ?? savedToken
+    if (manualToken) {
+      return {
+        source: 'manual' as TokenSource,
+        token: manualToken,
+        maskedToken: maskToken(manualToken),
+      }
+    }
+
+    // 3. gh CLI
+    const ghToken = yield* Effect.promise(tryGetGhToken)
+    if (ghToken) {
+      return {
+        source: 'gh_cli' as TokenSource,
+        token: ghToken,
+        maskedToken: maskToken(ghToken),
+      }
+    }
+
+    return {
+      source: 'none' as TokenSource,
+      token: null,
+      maskedToken: null,
+    }
+  })
+}
+
+export const 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 S.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: string) =>
+      Effect.gen(function* () {
+        sessionToken = token
+        savedToken = token
+        preferredSource = 'manual'
+        // Save to file for persistence across launches
+        yield* Effect.promise(() => saveTokenToFile(token))
+      }),
+
+    getTokenInfo: resolveTokenInfo,
+
+    setPreferredSource: (source: TokenSource) =>
+      Effect.sync(() => {
+        preferredSource = source === 'none' ? null : source
+      }),
+
+    getAvailableSources: () =>
+      Effect.gen(function* () {
+        const sources: TokenSource[] = []
+
+        // Check LAZYREVIEW_GITHUB_TOKEN only
+        const envToken = process.env['LAZYREVIEW_GITHUB_TOKEN']
+        if (envToken) {
+          sources.push('env')
+        }
+
+        // Check for manual token (session or saved)
+        if (sessionToken || savedToken) {
+          sources.push('manual')
+        }
+
+        // Check gh CLI
+        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
+        }
+        // Delete the saved token file
+        yield* Effect.promise(deleteSavedToken)
+      }),
+  }),
+)

package/src/services/Config.ts

@@ -0,0 +1,81 @@
+import { Context, Effect, Layer, Schema as S } from 'effect'
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { parse, stringify } from 'yaml'
+import { ConfigError } from '../models/errors'
+
+const KeybindingsSchema = S.Struct({
+  toggleSidebar: S.optionalWith(S.String, { default: () => 'b' }),
+  help: S.optionalWith(S.String, { default: () => '?' }),
+  quit: S.optionalWith(S.String, { default: () => 'q' }),
+})
+
+export class AppConfig extends S.Class<AppConfig>('AppConfig')({
+  provider: S.optionalWith(S.Literal('github'), {
+    default: () => 'github' as const,
+  }),
+  theme: S.optionalWith(S.String, { default: () => 'tokyo-night' }),
+  defaultOwner: S.optional(S.String),
+  defaultRepo: S.optional(S.String),
+  pageSize: S.optionalWith(S.Number.pipe(S.int(), S.between(1, 100)), {
+    default: () => 30,
+  }),
+  keybindings: S.optionalWith(KeybindingsSchema, {
+    default: () => ({ toggleSidebar: 'b', help: '?', quit: 'q' }),
+  }),
+}) {}
+
+const defaultConfig = S.decodeUnknownSync(AppConfig)({})
+
+export interface ConfigService {
+  readonly load: () => Effect.Effect<AppConfig, ConfigError>
+  readonly save: (config: AppConfig) => Effect.Effect<void, ConfigError>
+  readonly getPath: () => string
+}
+
+export class Config extends Context.Tag('Config')<Config, ConfigService>() {}
+
+function getConfigPath(): string {
+  return join(homedir(), '.config', 'lazyreview', 'config.yaml')
+}
+
+export const ConfigLive = Layer.succeed(
+  Config,
+  Config.of({
+    getPath: getConfigPath,
+
+    load: () =>
+      Effect.tryPromise({
+        try: async () => {
+          const configPath = getConfigPath()
+          try {
+            const content = await readFile(configPath, 'utf-8')
+            const parsed = parse(content)
+            return S.decodeUnknownSync(AppConfig)(parsed)
+          } catch {
+            return defaultConfig
+          }
+        },
+        catch: (error) =>
+          new ConfigError({
+            message: `Failed to load config: ${String(error)}`,
+            path: getConfigPath(),
+          }),
+      }),
+
+    save: (config: AppConfig) =>
+      Effect.tryPromise({
+        try: async () => {
+          const configPath = getConfigPath()
+          await mkdir(dirname(configPath), { recursive: true })
+          await writeFile(configPath, stringify(config), 'utf-8')
+        },
+        catch: (error) =>
+          new ConfigError({
+            message: `Failed to save config: ${String(error)}`,
+            path: getConfigPath(),
+          }),
+      }),
+  }),
+)

package/src/services/GitHubApi.ts

@@ -0,0 +1,262 @@
+import { Context, Effect, Layer, Schema as S } from 'effect'
+import { AuthError, GitHubError, NetworkError } from '../models/errors'
+import { PullRequest } from '../models/pull-request'
+import { Comment } from '../models/comment'
+import { Review } from '../models/review'
+import { FileChange } from '../models/file-change'
+import { Commit } from '../models/commit'
+import { Auth } from './Auth'
+
+const BASE_URL = 'https://api.github.com'
+
+export interface ListPRsOptions {
+  readonly state?: 'open' | 'closed' | 'all'
+  readonly sort?: 'created' | 'updated' | 'popularity' | 'long-running'
+  readonly direction?: 'asc' | 'desc'
+  readonly perPage?: number
+  readonly page?: number
+}
+
+type ApiError = GitHubError | NetworkError | AuthError
+
+export interface GitHubApiService {
+  readonly listPullRequests: (
+    owner: string,
+    repo: string,
+    options?: ListPRsOptions,
+  ) => Effect.Effect<readonly PullRequest[], ApiError>
+
+  readonly getPullRequest: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Effect.Effect<PullRequest, ApiError>
+
+  readonly getPullRequestFiles: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Effect.Effect<readonly FileChange[], ApiError>
+
+  readonly getPullRequestComments: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Effect.Effect<readonly Comment[], ApiError>
+
+  readonly getPullRequestReviews: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Effect.Effect<readonly Review[], ApiError>
+
+  readonly getPullRequestCommits: (
+    owner: string,
+    repo: string,
+    number: number,
+  ) => Effect.Effect<readonly Commit[], ApiError>
+
+  readonly getMyPRs: () => Effect.Effect<readonly PullRequest[], ApiError>
+
+  readonly getReviewRequests: () => Effect.Effect<
+    readonly PullRequest[],
+    ApiError
+  >
+
+  readonly getInvolvedPRs: () => Effect.Effect<readonly PullRequest[], ApiError>
+}
+
+export class GitHubApi extends Context.Tag('GitHubApi')<
+  GitHubApi,
+  GitHubApiService
+>() {}
+
+function fetchGitHub<A, I>(
+  path: string,
+  token: string,
+  schema: S.Schema<A, I>,
+): Effect.Effect<A, GitHubError | NetworkError> {
+  const url = `${BASE_URL}${path}`
+  const decode = S.decodeUnknownSync(schema)
+
+  return Effect.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,
+      })
+    },
+  })
+}
+
+// Schema for GitHub Search API response
+const SearchResultSchema = S.Struct({
+  total_count: S.Number,
+  incomplete_results: S.Boolean,
+  items: S.Array(PullRequest),
+})
+
+function fetchGitHubSearch(
+  query: string,
+  token: string,
+): Effect.Effect<readonly PullRequest[], GitHubError | NetworkError> {
+  const url = `${BASE_URL}/search/issues?q=${encodeURIComponent(query)}&per_page=100`
+  const decode = S.decodeUnknownSync(SearchResultSchema)
+
+  return Effect.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: ListPRsOptions): string {
+  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}` : ''
+}
+
+export const GitHubApiLive = Layer.effect(
+  GitHubApi,
+  Effect.gen(function* () {
+    const auth = yield* Auth
+
+    return GitHubApi.of({
+      listPullRequests: (owner, repo, options = {}) =>
+        Effect.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,
+            S.Array(PullRequest),
+          )
+        }),
+
+      getPullRequest: (owner, repo, number) =>
+        Effect.gen(function* () {
+          const token = yield* auth.getToken()
+          return yield* fetchGitHub(
+            `/repos/${owner}/${repo}/pulls/${number}`,
+            token,
+            PullRequest,
+          )
+        }),
+
+      getPullRequestFiles: (owner, repo, number) =>
+        Effect.gen(function* () {
+          const token = yield* auth.getToken()
+          return yield* fetchGitHub(
+            `/repos/${owner}/${repo}/pulls/${number}/files`,
+            token,
+            S.Array(FileChange),
+          )
+        }),
+
+      getPullRequestComments: (owner, repo, number) =>
+        Effect.gen(function* () {
+          const token = yield* auth.getToken()
+          return yield* fetchGitHub(
+            `/repos/${owner}/${repo}/pulls/${number}/comments`,
+            token,
+            S.Array(Comment),
+          )
+        }),
+
+      getPullRequestReviews: (owner, repo, number) =>
+        Effect.gen(function* () {
+          const token = yield* auth.getToken()
+          return yield* fetchGitHub(
+            `/repos/${owner}/${repo}/pulls/${number}/reviews`,
+            token,
+            S.Array(Review),
+          )
+        }),
+
+      getPullRequestCommits: (owner, repo, number) =>
+        Effect.gen(function* () {
+          const token = yield* auth.getToken()
+          return yield* fetchGitHub(
+            `/repos/${owner}/${repo}/pulls/${number}/commits`,
+            token,
+            S.Array(Commit),
+          )
+        }),
+
+      getMyPRs: () =>
+        Effect.gen(function* () {
+          const token = yield* auth.getToken()
+          return yield* fetchGitHubSearch('is:pr is:open author:@me', token)
+        }),
+
+      getReviewRequests: () =>
+        Effect.gen(function* () {
+          const token = yield* auth.getToken()
+          return yield* fetchGitHubSearch(
+            'is:pr is:open review-requested:@me',
+            token,
+          )
+        }),
+
+      getInvolvedPRs: () =>
+        Effect.gen(function* () {
+          const token = yield* auth.getToken()
+          return yield* fetchGitHubSearch('is:pr is:open involves:@me', token)
+        }),
+    })
+  }),
+)

package/src/services/Loading.ts

@@ -0,0 +1,54 @@
+import { Context, Layer } from 'effect'
+
+export interface LoadingState {
+  readonly isLoading: boolean
+  readonly message: string | null
+}
+
+type Listener = () => void
+
+export interface LoadingService {
+  readonly start: (message: string) => void
+  readonly stop: () => void
+  readonly getState: () => LoadingState
+  readonly subscribe: (listener: Listener) => () => void
+}
+
+export class Loading extends Context.Tag('Loading')<
+  Loading,
+  LoadingService
+>() {}
+
+function createLoadingService(): LoadingService {
+  let state: LoadingState = { isLoading: false, message: null }
+  const listeners = new Set<Listener>()
+
+  function notify(): void {
+    for (const listener of listeners) {
+      listener()
+    }
+  }
+
+  return {
+    start: (message: string) => {
+      state = { isLoading: true, message }
+      notify()
+    },
+
+    stop: () => {
+      state = { isLoading: false, message: null }
+      notify()
+    },
+
+    getState: () => state,
+
+    subscribe: (listener: Listener) => {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+  }
+}
+
+export const LoadingLive = Layer.sync(Loading, createLoadingService)