Download and cache issue results

Author: markerikson

packages/toolkit/scripts/issue-triage/README.md

@@ -38,6 +38,22 @@ Or for development (builds and runs):
 npm run dev
 ```
 
+### Using Cached Data
+
+The tool automatically saves fetched data to `cache/issues-data.json` after each run. To use cached data instead of fetching fresh data (useful for development and testing):
+
+```bash
+npm start -- --use-cache
+```
+
+Or with the dev command:
+
+```bash
+npm run dev -- --use-cache
+```
+
+**Note:** The `--use-cache` flag is primarily for development/testing purposes. It loads data from the cache file instantly without making API calls. If the cache file doesn't exist or is corrupted, the tool will automatically fetch fresh data.
+
 ## Project Structure
 
 ```

packages/toolkit/scripts/issue-triage/src/github/gh-client.ts

@@ -4,6 +4,8 @@
 
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
+import { promises as fs } from 'node:fs'
+import { join, dirname } from 'node:path'
 import type {
   GhIssueResponse,
   GhPullRequestResponse,
@@ -20,6 +22,7 @@ const execFileAsync = promisify(execFile)
 const MAX_BUFFER = 10 * 1024 * 1024 // 10MB
 const TIMEOUT = 30000 // 30 seconds
 const REPO = 'reduxjs/redux-toolkit'
+const CACHE_FILE = 'cache/issues-data.json'
 
 /**
  * Execute a gh CLI command and return stdout/stderr
@@ -248,17 +251,107 @@ export class GitHubClient {
     }
   }
 
+  /**
+   * Save issues and PRs to cache file
+   */
+  async saveToCache(issues: Issue[], prs: Issue[]): Promise<void> {
+    try {
+      console.log('💾 Saving data to cache...')
+
+      // Create cache directory if it doesn't exist
+      const cacheDir = dirname(CACHE_FILE)
+      await fs.mkdir(cacheDir, { recursive: true })
+
+      // Write cache file with pretty-printed JSON
+      const cacheData = { issues, prs }
+      await fs.writeFile(CACHE_FILE, JSON.stringify(cacheData, null, 2), 'utf8')
+
+      console.log(
+        `✓ Saved ${issues.length} issues and ${prs.length} PRs to cache`,
+      )
+    } catch (error) {
+      // Log warning but don't fail - caching is optional
+      console.warn(
+        '⚠️ Failed to save cache:',
+        error instanceof Error ? error.message : error,
+      )
+    }
+  }
+
+  /**
+   * Load issues and PRs from cache file
+   */
+  async loadFromCache(): Promise<{ issues: Issue[]; prs: Issue[] } | null> {
+    try {
+      const data = await fs.readFile(CACHE_FILE, 'utf8')
+      const parsed = JSON.parse(data)
+
+      // Validate cache structure
+      if (
+        !parsed.issues ||
+        !parsed.prs ||
+        !Array.isArray(parsed.issues) ||
+        !Array.isArray(parsed.prs)
+      ) {
+        console.warn('⚠️ Cache file has invalid structure, fetching fresh data')
+        return null
+      }
+
+      // Reconstruct Date objects from ISO strings
+      const reconstructDates = (item: any): Issue => ({
+        ...item,
+        created_at: new Date(item.created_at),
+        updated_at: new Date(item.updated_at),
+        closed_at: item.closed_at ? new Date(item.closed_at) : null,
+        merged_at: item.merged_at ? new Date(item.merged_at) : undefined,
+      })
+
+      return {
+        issues: parsed.issues.map(reconstructDates),
+        prs: parsed.prs.map(reconstructDates),
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        console.log('⚠️ Cache file not found, fetching fresh data')
+      } else if (error instanceof SyntaxError) {
+        console.warn('⚠️ Cache file corrupted, fetching fresh data')
+      } else {
+        console.warn(
+          '⚠️ Failed to load cache:',
+          error instanceof Error ? error.message : error,
+        )
+      }
+      return null
+    }
+  }
+
   /**
    * Fetch all open issues and PRs
    */
-  async fetchAll(): Promise<Issue[]> {
+  async fetchAll(options?: { useCache?: boolean }): Promise<Issue[]> {
+    // Try to load from cache if requested
+    if (options?.useCache) {
+      console.log('📦 Attempting to use cached data...')
+      const cached = await this.loadFromCache()
+
+      if (cached) {
+        console.log('📦 Using cached data')
+        return [...cached.issues, ...cached.prs]
+      }
+    }
+
+    // Fetch fresh data
+    console.log('🔄 Fetching fresh data...')
     console.log('Fetching all open issues and PRs...')
 
     const [issues, prs] = await Promise.all([
       this.fetchOpenIssues(),
       this.fetchOpenPRs(),
     ])
 
+    // Save to cache
+    await this.saveToCache(issues, prs)
+
     return [...issues, ...prs]
   }
 }

packages/toolkit/scripts/issue-triage/src/github/transformers.ts

@@ -6,17 +6,39 @@ import type {
   GhIssueResponse,
   GhPullRequestResponse,
   GhIssueDetailResponse,
+  GhComment,
+  SimplifiedComment,
   Issue,
   DetailedIssue,
 } from './types.js'
 
+/**
+ * Simplify a comment object for caching by removing unnecessary fields
+ */
+function simplifyComment(comment: GhComment): SimplifiedComment {
+  return {
+    author: comment.author.login,
+    authorAssociation: comment.authorAssociation,
+    body: comment.body,
+    createdAt: comment.createdAt,
+  }
+}
+
 /**
  * Transform a raw GitHub issue or PR response to our internal format
  */
 export function transformIssue(
   raw: GhIssueResponse | GhPullRequestResponse,
   type: 'issue' | 'pr',
 ): Issue {
+  // Handle comments - can be either a count or full array
+  const commentCount =
+    typeof raw.comments === 'number' ? raw.comments : raw.comments.length
+
+  const simplifiedComments = Array.isArray(raw.comments)
+    ? raw.comments.map(simplifyComment)
+    : undefined
+
   const base: Issue = {
     number: raw.number,
     title: raw.title,
@@ -28,8 +50,8 @@ export function transformIssue(
     url: raw.url,
     author: raw.author.login,
     labels: raw.labels.map((label) => label.name),
-    assignees: raw.assignees.map((assignee) => assignee.login),
-    comment_count: raw.comments,
+    comment_count: commentCount,
+    comments: simplifiedComments,
     body: raw.body || '',
   }
 
@@ -62,18 +84,12 @@ export function transformDetailedIssue(
     url: raw.url,
     author: raw.author.login,
     labels: raw.labels.map((label) => label.name),
-    assignees: raw.assignees.map((assignee) => assignee.login),
     comment_count: raw.comments.length,
     body: raw.body || '',
   }
 
-  // Transform comments
-  const comments = raw.comments.map((comment) => ({
-    author: comment.author.login,
-    body: comment.body,
-    created_at: new Date(comment.createdAt),
-    updated_at: new Date(comment.updatedAt),
-  }))
+  // Transform comments to simplified format
+  const comments = raw.comments.map(simplifyComment)
 
   return {
     ...baseIssue,

packages/toolkit/scripts/issue-triage/src/github/types.ts

@@ -2,6 +2,40 @@
  * GitHub API response types and internal data models
  */
 
+/**
+ * Comment object from GitHub API
+ */
+export interface GhComment {
+  id: string
+  author: {
+    login: string
+  }
+  authorAssociation: string
+  body: string
+  createdAt: string
+  includesCreatedEdit: boolean
+  isMinimized: boolean
+  minimizedReason: string
+  reactionGroups: Array<{
+    content: string
+    users: {
+      totalCount: number
+    }
+  }>
+  url: string
+  viewerDidAuthor: boolean
+}
+
+/**
+ * Simplified comment for caching
+ */
+export interface SimplifiedComment {
+  author: string
+  authorAssociation: string
+  body: string
+  createdAt: string
+}
+
 /**
  * Raw response from `gh issue list --json` command
  */
@@ -23,7 +57,7 @@ export interface GhIssueResponse {
   assignees: Array<{
     login: string
   }>
-  comments: number
+  comments: number | GhComment[] // Can be count or full array
   body: string
 }
 
@@ -77,14 +111,7 @@ export interface GhIssueDetailResponse {
     login: string
   }>
   body: string
-  comments: Array<{
-    author: {
-      login: string
-    }
-    body: string
-    createdAt: string
-    updatedAt: string
-  }>
+  comments: GhComment[]
 }
 
 /**
@@ -101,8 +128,8 @@ export interface Issue {
   url: string
   author: string
   labels: string[]
-  assignees: string[]
   comment_count: number
+  comments?: SimplifiedComment[] // Optional simplified comments for caching
   body: string
   // PR-specific fields
   is_draft?: boolean
@@ -114,10 +141,5 @@ export interface Issue {
  * Detailed issue with comments loaded
  */
 export interface DetailedIssue extends Issue {
-  comments: Array<{
-    author: string
-    body: string
-    created_at: Date
-    updated_at: Date
-  }>
+  comments: SimplifiedComment[]
 }

packages/toolkit/scripts/issue-triage/src/index.ts

@@ -12,6 +12,9 @@ async function main() {
   console.log('==================================\n')
 
   try {
+    // Parse CLI arguments
+    const useCache = process.argv.includes('--use-cache')
+
     // Step 1: Verify gh CLI is available and authenticated
     console.log('Checking GitHub CLI...')
     await checkGhCli()
@@ -22,7 +25,7 @@ async function main() {
 
     // Step 3: Fetch all open issues and PRs
     console.log('Fetching data from reduxjs/redux-toolkit...\n')
-    const allItems = await client.fetchAll()
+    const allItems = await client.fetchAll({ useCache })
 
     // Step 4: Display summary statistics
     const issues = allItems.filter((item) => item.type === 'issue')
@@ -51,9 +54,9 @@ async function main() {
           console.log(`Author: ${detailed.author}`)
           console.log(`Created: ${detailed.created_at.toISOString()}`)
           console.log(`Labels: ${detailed.labels.join(', ') || 'none'}`)
-          console.log(`Comments: ${detailed.comments.length}`)
+          console.log(`Comments: ${detailed.comments?.length || 0}`)
 
-          if (detailed.comments.length > 0) {
+          if (detailed.comments && detailed.comments.length > 0) {
             console.log(
               `Latest comment by: ${detailed.comments[detailed.comments.length - 1].author}`,
             )