gemini-cli/.github/workflows/label-workstream-rollup.yml at 09259a8ec497dea2247271e2b090918b83766aa9 · AnushkaPandit-21/gemini-cli · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
name: 'Label Workstream Rollup'

on:
  issues:
    types: ['opened', 'edited', 'reopened']
  schedule:
    - cron: '0 * * * *'
  workflow_dispatch:

jobs:
  labeler:
    if: "github.repository == 'google-gemini/gemini-cli'"
    runs-on: 'ubuntu-latest'
    permissions:
      issues: 'write'
    steps:
      - name: 'Check for Parent Workstream and Apply Label'
        uses: 'actions/github-script@v7'
        with:
          script: |
            const labelToAdd = 'workstream-rollup';

            // Allow-list of parent issue URLs
            const allowedParentUrls = [
              'https://github.com/google-gemini/gemini-cli/issues/15374',
              'https://github.com/google-gemini/gemini-cli/issues/15456',
              'https://github.com/google-gemini/gemini-cli/issues/15324',
              'https://github.com/google-gemini/gemini-cli/issues/17202',
              'https://github.com/google-gemini/gemini-cli/issues/17203'
            ];

            // Single issue processing (for event triggers)
            async function processSingleIssue(owner, repo, number) {
              const query = `
                query($owner:String!, $repo:String!, $number:Int!) {
                  repository(owner:$owner, name:$repo) {
                    issue(number:$number) {
                      number
                      parent {
                        url
                        parent {
                          url
                          parent {
                            url
                            parent {
                              url
                              parent {
                                url
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              `;
              try {
                const result = await github.graphql(query, { owner, repo, number });

                if (!result || !result.repository || !result.repository.issue) {
                  console.log(`Issue #${number} not found or data missing.`);
                  return;
                }

                const issue = result.repository.issue;
                await checkAndLabel(issue, owner, repo);
              } catch (error) {
                console.error(`Failed to process issue #${number}:`, error);
                throw error; // Re-throw to be caught by main execution
              }
            }

            // Bulk processing (for schedule/dispatch)
            async function processAllOpenIssues(owner, repo) {
              const query = `
                query($owner:String!, $repo:String!, $cursor:String) {
                  repository(owner:$owner, name:$repo) {
                    issues(first: 100, states: OPEN, after: $cursor) {
                      pageInfo {
                        hasNextPage
                        endCursor
                      }
                      nodes {
                        number
                        parent {
                          url
                          parent {
                            url
                            parent {
                              url
                              parent {
                                url
                                parent {
                                  url
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              `;

              let hasNextPage = true;
              let cursor = null;

              while (hasNextPage) {
                try {
                  const result = await github.graphql(query, { owner, repo, cursor });

                  if (!result || !result.repository || !result.repository.issues) {
                     console.error('Invalid response structure from GitHub API');
                     break;
                  }

                  const issues = result.repository.issues.nodes || [];

                  console.log(`Processing batch of ${issues.length} issues...`);
                  for (const issue of issues) {
                    await checkAndLabel(issue, owner, repo);
                  }

                  hasNextPage = result.repository.issues.pageInfo.hasNextPage;
                  cursor = result.repository.issues.pageInfo.endCursor;
                } catch (error) {
                  console.error('Failed to fetch issues batch:', error);
                  throw error; // Re-throw to be caught by main execution
                }
              }
            }

            async function checkAndLabel(issue, owner, repo) {
              if (!issue || !issue.parent) return;

              let currentParent = issue.parent;
              let tracedParents = [];
              let matched = false;

              while (currentParent) {
                tracedParents.push(currentParent.url);

                if (allowedParentUrls.includes(currentParent.url)) {
                  console.log(`SUCCESS: Issue #${issue.number} is a descendant of ${currentParent.url}. Trace: ${tracedParents.join(' -> ')}. Adding label.`);
                  await github.rest.issues.addLabels({
                    owner,
                    repo,
                    issue_number: issue.number,
                    labels: [labelToAdd]
                  });
                  matched = true;
                  break;
                }
                currentParent = currentParent.parent;
              }

              if (!matched && context.eventName === 'issues') {
                 console.log(`Issue #${issue.number} did not match any allowed workstreams. Trace: ${tracedParents.join(' -> ') || 'None'}.`);
              }
            }

            // Main execution
            try {
              if (context.eventName === 'issues') {
                console.log(`Processing single issue #${context.payload.issue.number}...`);
                await processSingleIssue(context.repo.owner, context.repo.repo, context.payload.issue.number);
              } else {
                console.log(`Running for event: ${context.eventName}. Processing all open issues...`);
                await processAllOpenIssues(context.repo.owner, context.repo.repo);
              }
            } catch (error) {
              core.setFailed(`Workflow failed: ${error.message}`);
            }