main.ts

#!/usr/bin/env -S deno run --allow-net --allow-write

import { Octokit, RestEndpointMethodTypes } from "@octokit/rest"
import { parseArgs } from "@std/cli/parse-args"

type OrgMember =
  RestEndpointMethodTypes["orgs"]["listMembers"]["response"]["data"][0]

class ProgressIndicator {
  private totalMembers = 0
  private currentPage = 0
  private isRunning = false

  start() {
    this.isRunning = true
    this.render()
  }

  update(page: number, pageMembers: number) {
    this.currentPage = page
    this.totalMembers += pageMembers
    this.render()
  }

  finish(filename: string) {
    this.isRunning = false
    this.clearLine()
    console.log(`\n✅ Successfully exported ${this.totalMembers} members to ${filename}`)
  }

  error(message: string) {
    this.isRunning = false
    this.clearLine()
    console.error(`\n❌ ${message}`)
  }

  private render() {
    if (!this.isRunning) return

    this.clearLine()
    const spinner = this.getSpinner()
    const message = `${spinner} Fetching page ${this.currentPage} | ${this.totalMembers} members collected`
    Deno.stdout.writeSync(new TextEncoder().encode(`\r${message}`))
  }

  private clearLine() {
    Deno.stdout.writeSync(new TextEncoder().encode('\r\x1b[K'))
  }

  private getSpinner() {
    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
    return frames[Math.floor(Date.now() / 100) % frames.length]
  }
}

async function* fetchOrgMembers(
  org: string,
  token: string,
  progress: ProgressIndicator,
): AsyncGenerator<OrgMember[], void, unknown> {
  const octokit = new Octokit({
    auth: token,
  })

  let page = 1
  const perPage = 100

  while (true) {
    try {
      const response = await octokit.rest.orgs.listMembers({
        org,
        per_page: perPage,
        page,
      })

      if (response.data.length === 0) {
        break
      }

      progress.update(page, response.data.length)
      yield response.data

      if (response.data.length < perPage) {
        break
      }

      page++
    } catch (error) {
      progress.error(`Error fetching members: ${error}`)
      throw error
    }
  }
}

async function exportToJsonlStream(
  membersGenerator: AsyncGenerator<OrgMember[], void, unknown>,
  filename: string,
): Promise<void> {
  const file = await Deno.open(filename, { write: true, create: true, truncate: true })
  const encoder = new TextEncoder()

  try {
    for await (const membersBatch of membersGenerator) {
      const jsonlContent = membersBatch
        .map((member) => JSON.stringify(member))
        .join("\n") + "\n"

      await file.write(encoder.encode(jsonlContent))
    }
  } finally {
    file.close()
  }
}

async function main() {
  const args = parseArgs(Deno.args, {
    string: ["token", "org"],
    alias: {
      t: "token",
      o: "org",
    },
  })

  const { org, token } = args

  if (!org || !token) {
    const scriptName = import.meta.url.split("/").pop()
    console.error(`Usage: deno run --allow-net --allow-write ${scriptName} --org <organization> --token <github_token>`)
    console.error("Options:")
    console.error("  --org, -o     GitHub organization name")
    console.error("  --token, -t   GitHub personal access token")
    console.error("\nExample:")
    console.error(`  deno run --allow-net --allow-write ${scriptName} --org microsoft --token ghp_xxxxxxxxxxxx`)
    Deno.exit(1)
  }

  try {
    const progress = new ProgressIndicator()
    console.log(`🚀 Fetching members for organization: ${org}`)

    progress.start()
    const membersGenerator = fetchOrgMembers(org, token, progress)
    const filename = `${org}-members.jsonl`

    await exportToJsonlStream(membersGenerator, filename)
    progress.finish(filename)
  } catch (error) {
    console.error(`\n❌ Error: ${error}`)
    Deno.exit(1)
  }
}

if (import.meta.main) {
  main()
}