ci-triage 0.1.0 → 0.3.0

package/dist/multi.js

@@ -0,0 +1,116 @@
+function reportFailures(report) {
+    const failures = [];
+    for (const job of report.jobs) {
+        for (const step of job.steps ?? []) {
+            failures.push(...step.failures);
+        }
+    }
+    return failures;
+}
+function normalizeError(error) {
+    return error.replace(/\s+/g, ' ').trim();
+}
+export function detectSharedPatterns(reports) {
+    const byFixAction = new Map();
+    const byCategory = new Map();
+    const byErrorSubstring = new Map();
+    for (const report of reports) {
+        const failures = reportFailures(report);
+        const repoFixActions = new Set();
+        const repoCategories = new Set();
+        const repoErrorSubstrings = new Set();
+        for (const failure of failures) {
+            repoFixActions.add(failure.fix_action ?? 'unknown');
+            repoCategories.add(failure.category);
+            const normalized = normalizeError(failure.error);
+            if (normalized.length > 20) {
+                repoErrorSubstrings.add(normalized.slice(0, 120));
+            }
+        }
+        for (const action of repoFixActions) {
+            const repos = byFixAction.get(action) ?? new Set();
+            repos.add(report.repo);
+            byFixAction.set(action, repos);
+        }
+        for (const category of repoCategories) {
+            const repos = byCategory.get(category) ?? new Set();
+            repos.add(report.repo);
+            byCategory.set(category, repos);
+        }
+        for (const substring of repoErrorSubstrings) {
+            const repos = byErrorSubstring.get(substring) ?? new Set();
+            repos.add(report.repo);
+            byErrorSubstring.set(substring, repos);
+        }
+    }
+    const patterns = [];
+    for (const [fix_action, repos] of byFixAction) {
+        if (repos.size >= 2) {
+            patterns.push({
+                fix_action,
+                repos: [...repos].sort(),
+                description: `Common fix action across repos: ${fix_action}`,
+            });
+        }
+    }
+    for (const [category, repos] of byCategory) {
+        if (repos.size >= 2) {
+            patterns.push({
+                category,
+                repos: [...repos].sort(),
+                description: `Common category across repos: ${category}`,
+            });
+        }
+    }
+    for (const [error_substring, repos] of byErrorSubstring) {
+        if (repos.size >= 2) {
+            patterns.push({
+                error_substring,
+                repos: [...repos].sort(),
+                description: `Common error text across repos: ${error_substring}`,
+            });
+        }
+    }
+    return patterns;
+}
+export function formatMultiSummary(reports, patterns) {
+    const lines = [`Multi-repo triage: ${reports.length} repos`, ''];
+    if (patterns.length === 0) {
+        lines.push('Shared patterns detected: none', '');
+    }
+    else {
+        lines.push('Shared patterns detected:');
+        for (const pattern of patterns) {
+            const repos = pattern.repos.map((repo) => repo.split('/').at(-1) ?? repo).join(', ');
+            if (pattern.fix_action) {
+                lines.push(`  [${pattern.fix_action}] ${pattern.repos.length} repos affected: ${repos}`);
+            }
+            else if (pattern.category) {
+                lines.push(`  [${pattern.category}] ${pattern.repos.length} repos affected: ${repos}`);
+            }
+            else if (pattern.error_substring) {
+                lines.push(`  [error] ${pattern.repos.length} repos affected: ${repos}`);
+            }
+            lines.push(`    -> ${pattern.description}`);
+        }
+        lines.push('');
+    }
+    lines.push('Per-repo:');
+    for (const report of reports) {
+        const failures = reportFailures(report);
+        const actionCounts = new Map();
+        for (const failure of failures) {
+            const action = failure.fix_action ?? 'unknown';
+            actionCounts.set(action, (actionCounts.get(action) ?? 0) + 1);
+        }
+        const actionSummary = [...actionCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([action, count]) => `${action} x${count}`)
+            .join(', ');
+        lines.push(`  ${report.repo} - ${failures.length} failures${actionSummary ? ` (${actionSummary})` : ''}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function buildMultiJson(reports, patterns) {
+    return `${JSON.stringify({ repos: reports, patterns }, null, 2)}\n`;
+}

package/dist/parser.js

@@ -200,3 +200,119 @@ export function parseFailures(rawLog) {
     flush();
     return dedupeFailures(failures);
 }
+function hasErrorContext(line) {
+    return /\b(?:error|failed|failure|denied|invalid|missing|not found|unable|cannot)\b/i.test(line);
+}
+function inferStepName(lines, index) {
+    for (let i = index; i >= 0 && i >= index - 40; i -= 1) {
+        const step = parseStepName(lines[i] ?? '');
+        if (step) {
+            return step;
+        }
+    }
+    return 'Unknown step';
+}
+function createInfraFailure(lines, index, error) {
+    const line = lines[index] ?? '';
+    const location = parseLocation(line);
+    const stack = [];
+    if (index + 1 < lines.length && isStackLine(lines[index + 1] ?? '')) {
+        stack.push((lines[index + 1] ?? '').trim());
+    }
+    return {
+        stepName: inferStepName(lines, index),
+        error: error.trim(),
+        stack,
+        location,
+        rawLines: [line],
+    };
+}
+export function parseInfraFailures(rawLog) {
+    if (!rawLog || rawLog.trim().length === 0) {
+        return [];
+    }
+    const cleanedLog = stripAnsiAndTimestamps(rawLog);
+    const lines = cleanedLog
+        .split(/\r?\n/)
+        .slice(0, MAX_LINES)
+        .map(sanitizeLine);
+    const failures = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        if (!line) {
+            continue;
+        }
+        const context = `${lines[i - 1] ?? ''}\n${line}\n${lines[i + 1] ?? ''}`;
+        // Shell script/runtime errors from bash/sh.
+        if (/^.+:\s*line\s+\d+:\s*.+$/i.test(line) ||
+            /\bcommand not found\b/i.test(line) ||
+            /\bpermission denied\b/i.test(line) ||
+            /\bno such file or directory\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // HTTP errors.
+        if (/\bHTTP\s*(?:403|404|429|5\d{2})\b/i.test(line) || /\b(?:403 Forbidden|404 Not Found)\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // GitHub Actions explicit step failure line.
+        const processExit = line.match(/\bError:\s*Process completed with exit code\s+(\d+)\b/i);
+        if (processExit && Number(processExit[1]) !== 0) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // Missing env/token in error context.
+        if (/\b(?:GITHUB_TOKEN|GH_TOKEN|GITLAB_TOKEN|CIRCLE_TOKEN)\b/.test(line) && hasErrorContext(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // Input/output file conflicts.
+        if (/\binput file is output file\b/i.test(line) || /\bis the same file\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // GitHub Pages deploy failures.
+        if (/\bError:\s*Get Pages site failed\b/i.test(line) ||
+            (/\bHttpError:\s*Not Found\b/i.test(line) && /\bpages?\b/i.test(context))) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // CodeQL/configuration errors.
+        if (/\bconfiguration error\b/i.test(line) && /\b(?:codeql|code[- ]scanning)\b/i.test(context)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // npm/node failures.
+        if (/\bnpm ERR!\b/i.test(line) || /\bCannot find module\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // Generic exit code failures not already captured.
+        const genericExit = line.match(/\bexit code\s+([1-9]\d*)\b/i);
+        if (genericExit) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // Generic explicit error prefix catch for shell-like errors.
+        if (/^error:\s+.+$/i.test(line) && !/\bexit code\s+0\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+    }
+    return dedupeFailures(failures);
+}
+export function parseAllFailures(rawLog) {
+    const combined = [...parseFailures(rawLog), ...parseInfraFailures(rawLog)];
+    const seen = new Set();
+    const deduped = [];
+    for (const failure of combined) {
+        const key = failure.error.trim();
+        if (!key || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(failure);
+    }
+    return deduped;
+}

package/dist/providers/circleci.js

@@ -0,0 +1,106 @@
+const CIRCLE_API = 'https://circleci.com/api/v2';
+function token() {
+    return process.env['CIRCLE_TOKEN'];
+}
+async function circleFetch(path) {
+    const tok = token();
+    if (!tok)
+        throw new Error('CIRCLE_TOKEN env var is required for CircleCI provider.');
+    const res = await fetch(`${CIRCLE_API}${path}`, {
+        headers: { 'Circle-Token': tok },
+    });
+    if (!res.ok)
+        throw new Error(`CircleCI API error ${res.status}: ${res.statusText} — ${path}`);
+    return res.json();
+}
+export class CircleCiProvider {
+    name = 'circleci';
+    async canHandle(_repo) {
+        if (!token()) {
+            console.error([
+                'Error: CircleCI provider requires CIRCLE_TOKEN environment variable.',
+                '  Create a personal API token at: https://app.circleci.com/settings/user/tokens',
+                '  Then set: export CIRCLE_TOKEN=<your-token>',
+            ].join('\n'));
+            return false;
+        }
+        return true;
+    }
+    /** repo format: gh/orgname/reponame or bb/org/repo */
+    async listRuns(repo, limit) {
+        const data = await circleFetch(`/project/${repo}/pipeline?page-token=&per_page=${Math.min(limit, 50)}`);
+        return data.items.map((p) => ({
+            id: p.id,
+            displayTitle: `Pipeline #${p.number}`,
+            workflowName: 'CircleCI',
+            conclusion: p.state === 'created' ? null : p.state,
+            url: `https://app.circleci.com/pipelines/${repo}/${p.number}`,
+        }));
+    }
+    async resolveRun(repo, runId) {
+        const runs = await this.listRuns(repo, 20);
+        if (runId !== undefined) {
+            const run = runs.find((r) => String(r.id) === String(runId));
+            if (!run)
+                throw new Error(`Pipeline ${runId} not found for ${repo}.`);
+            return run;
+        }
+        const failed = runs.find((r) => r.conclusion === 'errored' || r.conclusion === 'failed');
+        if (!failed)
+            throw new Error(`No failed pipelines found for ${repo} in recent history.`);
+        return failed;
+    }
+    async fetchLogs(ref) {
+        if (!ref.runId)
+            throw new Error('runId required for CircleCI provider');
+        const byJob = {};
+        try {
+            // Get workflows for this pipeline
+            const wfData = await circleFetch(`/pipeline/${ref.runId}/workflow`);
+            for (const wf of wfData.items) {
+                if (wf.status !== 'failed')
+                    continue;
+                const jobData = await circleFetch(`/workflow/${wf.id}/job`);
+                for (const job of jobData.items) {
+                    if (job.status !== 'failed' || !job.job_number)
+                        continue;
+                    try {
+                        const artifacts = await circleFetch(`/project/${ref.repo}/${job.job_number}/artifacts`);
+                        for (const artifact of artifacts.items) {
+                            if (artifact.path.endsWith('.log') || artifact.path.endsWith('output.txt')) {
+                                const logRes = await fetch(artifact.url, {
+                                    headers: { 'Circle-Token': token() },
+                                });
+                                if (logRes.ok)
+                                    byJob[job.name] = await logRes.text();
+                            }
+                        }
+                    }
+                    catch {
+                        // skip if artifact fetch fails
+                    }
+                }
+            }
+        }
+        catch {
+            // return empty on any error
+        }
+        return { combined: Object.values(byJob).join('\n'), byJob };
+    }
+    async fetchMetadata(ref) {
+        if (!ref.runId)
+            return { headSha: '', headBranch: '', event: '' };
+        try {
+            const pipeline = await circleFetch(`/pipeline/${ref.runId}`);
+            return {
+                headSha: pipeline.vcs?.revision ?? '',
+                headBranch: pipeline.vcs?.branch ?? '',
+                event: 'push',
+                url: `https://app.circleci.com/pipelines/${ref.repo}/${pipeline.number}`,
+            };
+        }
+        catch {
+            return { headSha: '', headBranch: '', event: '' };
+        }
+    }
+}

package/dist/providers/github.js

@@ -0,0 +1,103 @@
+import { execFileSync } from 'node:child_process';
+function runJson(args) {
+    const out = execFileSync('gh', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    return JSON.parse(out);
+}
+function runText(args) {
+    return execFileSync('gh', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+}
+function checkGhAvailable() {
+    try {
+        execFileSync('gh', ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function checkGhAuth() {
+    try {
+        execFileSync('gh', ['auth', 'status'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class GitHubProvider {
+    name = 'github';
+    async canHandle(_repo) {
+        if (!checkGhAvailable()) {
+            console.error([
+                'Error: `gh` CLI is required for GitHub mode but was not found.',
+                '  Install: https://cli.github.com/',
+                '  macOS:   brew install gh',
+                '  After installing, run: gh auth login',
+            ].join('\n'));
+            return false;
+        }
+        if (!checkGhAuth()) {
+            console.error([
+                'Error: `gh` CLI is installed but not authenticated.',
+                '  Run: gh auth login',
+                '  If you intended to use GitLab or CircleCI, pass --provider gitlab|circleci',
+            ].join('\n'));
+            return false;
+        }
+        return true;
+    }
+    async listRuns(repo, limit) {
+        const runs = runJson([
+            'run', 'list', '--repo', repo, '--limit', String(limit),
+            '--json', 'databaseId,displayTitle,workflowName,conclusion,url',
+        ]);
+        return runs.map((r) => ({
+            id: r.databaseId,
+            displayTitle: r.displayTitle,
+            workflowName: r.workflowName,
+            conclusion: r.conclusion,
+            url: r.url,
+        }));
+    }
+    async resolveRun(repo, runId) {
+        const runs = await this.listRuns(repo, 100);
+        if (runId !== undefined) {
+            const run = runs.find((r) => String(r.id) === String(runId));
+            if (!run)
+                throw new Error(`Run ${runId} not found in recent runs for ${repo}.`);
+            return run;
+        }
+        // Most recent failed run
+        const failed = runs.find((r) => r.conclusion === 'failure');
+        if (!failed)
+            throw new Error(`No failed runs found for ${repo} in recent history.`);
+        return failed;
+    }
+    async fetchLogs(ref) {
+        if (!ref.runId)
+            throw new Error('runId required for GitHub provider');
+        try {
+            const combined = runText([
+                'run', 'view', String(ref.runId), '--repo', ref.repo, '--log-failed',
+            ]);
+            return { combined };
+        }
+        catch {
+            return { combined: '' };
+        }
+    }
+    async fetchMetadata(ref) {
+        if (!ref.runId)
+            return { headSha: '', headBranch: '', event: '' };
+        try {
+            const result = runJson([
+                'run', 'view', String(ref.runId), '--repo', ref.repo,
+                '--json', 'headSha,headBranch,event',
+            ]);
+            return result;
+        }
+        catch {
+            return { headSha: '', headBranch: '', event: '' };
+        }
+    }
+}

package/dist/providers/gitlab.js

@@ -0,0 +1,96 @@
+const GITLAB_API = 'https://gitlab.com/api/v4';
+function token() {
+    return process.env['GITLAB_TOKEN'];
+}
+async function gitlabFetch(path) {
+    const tok = token();
+    if (!tok)
+        throw new Error('GITLAB_TOKEN env var is required for GitLab provider.');
+    const res = await fetch(`${GITLAB_API}${path}`, {
+        headers: { 'PRIVATE-TOKEN': tok },
+    });
+    if (!res.ok)
+        throw new Error(`GitLab API error ${res.status}: ${res.statusText} — ${path}`);
+    return res.json();
+}
+function encodedRepo(repo) {
+    // repo format: group/project — encode slashes for GitLab API
+    return encodeURIComponent(repo);
+}
+export class GitLabProvider {
+    name = 'gitlab';
+    async canHandle(_repo) {
+        if (!token()) {
+            console.error([
+                'Error: GitLab provider requires GITLAB_TOKEN environment variable.',
+                '  Create a personal access token at: https://gitlab.com/-/profile/personal_access_tokens',
+                '  Required scopes: read_api',
+                '  Then set: export GITLAB_TOKEN=<your-token>',
+            ].join('\n'));
+            return false;
+        }
+        return true;
+    }
+    async listRuns(repo, limit) {
+        const pipelines = await gitlabFetch(`/projects/${encodedRepo(repo)}/pipelines?per_page=${limit}`);
+        return pipelines.map((p) => ({
+            id: p.id,
+            displayTitle: `Pipeline #${p.id} (${p.ref})`,
+            workflowName: 'GitLab CI',
+            conclusion: p.status === 'success' ? 'success' : p.status === 'failed' ? 'failure' : p.status,
+            url: p.web_url,
+        }));
+    }
+    async resolveRun(repo, runId) {
+        if (runId !== undefined) {
+            const pipeline = await gitlabFetch(`/projects/${encodedRepo(repo)}/pipelines/${runId}`);
+            return {
+                id: pipeline.id,
+                displayTitle: `Pipeline #${pipeline.id} (${pipeline.ref})`,
+                workflowName: 'GitLab CI',
+                conclusion: pipeline.status === 'success' ? 'success' : pipeline.status === 'failed' ? 'failure' : pipeline.status,
+                url: pipeline.web_url,
+            };
+        }
+        const runs = await this.listRuns(repo, 20);
+        const failed = runs.find((r) => r.conclusion === 'failure');
+        if (!failed)
+            throw new Error(`No failed pipelines found for ${repo} in recent history.`);
+        return failed;
+    }
+    async fetchLogs(ref) {
+        if (!ref.runId)
+            throw new Error('runId required for GitLab provider');
+        const jobs = await gitlabFetch(`/projects/${encodedRepo(ref.repo)}/pipelines/${ref.runId}/jobs?scope[]=failed`);
+        const byJob = {};
+        for (const job of jobs) {
+            try {
+                const logRes = await fetch(`${GITLAB_API}/projects/${encodedRepo(ref.repo)}/jobs/${job.id}/trace`, { headers: { 'PRIVATE-TOKEN': token() } });
+                if (logRes.ok) {
+                    byJob[job.name] = await logRes.text();
+                }
+            }
+            catch {
+                // skip job if log fetch fails
+            }
+        }
+        const combined = Object.values(byJob).join('\n');
+        return { combined, byJob };
+    }
+    async fetchMetadata(ref) {
+        if (!ref.runId)
+            return { headSha: '', headBranch: '', event: '' };
+        try {
+            const pipeline = await gitlabFetch(`/projects/${encodedRepo(ref.repo)}/pipelines/${ref.runId}`);
+            return {
+                headSha: pipeline.sha,
+                headBranch: pipeline.ref,
+                event: 'push',
+                url: pipeline.web_url,
+            };
+        }
+        catch {
+            return { headSha: '', headBranch: '', event: '' };
+        }
+    }
+}

package/dist/providers/index.js

@@ -0,0 +1,44 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { GitHubProvider } from './github.js';
+import { GitLabProvider } from './gitlab.js';
+import { CircleCiProvider } from './circleci.js';
+export { GitHubProvider } from './github.js';
+export { GitLabProvider } from './gitlab.js';
+export { CircleCiProvider } from './circleci.js';
+const providers = {
+    github: () => new GitHubProvider(),
+    gitlab: () => new GitLabProvider(),
+    circleci: () => new CircleCiProvider(),
+};
+/**
+ * Detect CI provider by environment variables first, then local repo markers.
+ * Env vars take priority so detection works in temp checkout dirs (e.g. /tmp).
+ */
+export function detectProvider(cwd = process.cwd()) {
+    // Environment-variable detection (reliable in CI; works from any cwd)
+    if (process.env['GITLAB_CI'])
+        return 'gitlab';
+    if (process.env['CIRCLECI'])
+        return 'circleci';
+    if (process.env['GITHUB_ACTIONS'])
+        return 'github';
+    // Fallback: filesystem markers in the working directory
+    if (existsSync(join(cwd, '.gitlab-ci.yml')))
+        return 'gitlab';
+    if (existsSync(join(cwd, '.circleci')))
+        return 'circleci';
+    return 'github';
+}
+/** Get a provider instance by name, or auto-detect if not specified. */
+export function getProvider(name) {
+    if (name) {
+        const factory = providers[name];
+        if (!factory) {
+            throw new Error(`Unknown provider: "${name}". Valid options: github, gitlab, circleci`);
+        }
+        return factory();
+    }
+    const detected = detectProvider();
+    return providers[detected]();
+}

package/dist/providers/types.js

@@ -0,0 +1,2 @@
+/** Provider abstraction for multi-CI support. */
+export {};

package/dist/repo-context.js

@@ -0,0 +1,97 @@
+import { execFile } from 'node:child_process';
+function runGh(args) {
+    return new Promise((resolve, reject) => {
+        execFile('gh', args, { encoding: 'utf8' }, (error, stdout, stderr) => {
+            if (error) {
+                const err = error;
+                err.stdout = stdout ?? '';
+                err.stderr = stderr ?? '';
+                reject(err);
+                return;
+            }
+            resolve({ stdout: stdout ?? '', stderr: stderr ?? '' });
+        });
+    });
+}
+function parseScopes(statusOutput) {
+    const line = statusOutput
+        .split('\n')
+        .map((l) => l.trim())
+        .find((l) => /^token scopes:/i.test(l));
+    if (!line)
+        return [];
+    const raw = line.replace(/^token scopes:\s*/i, '').replace(/'/g, '').trim();
+    if (!raw || /^none$/i.test(raw))
+        return [];
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function normalizePlan(planName) {
+    const normalized = (planName ?? '').toLowerCase();
+    if (normalized.includes('enterprise'))
+        return 'enterprise';
+    if (normalized.includes('team'))
+        return 'team';
+    if (normalized.includes('pro'))
+        return 'pro';
+    if (normalized.includes('free'))
+        return 'free';
+    return undefined;
+}
+export async function fetchRepoContext(repo) {
+    let repoInfo;
+    try {
+        const { stdout } = await runGh(['api', `repos/${repo}`]);
+        repoInfo = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    const context = {
+        repo,
+        private: repoInfo.private ?? false,
+        visibility: repoInfo.visibility ?? (repoInfo.private ? 'private' : 'public'),
+        hasPages: repoInfo.has_pages ?? false,
+        pagesEnabled: false,
+        defaultBranch: repoInfo.default_branch ?? '',
+        workflowFiles: [],
+        hasCodeScanning: false,
+        tokenScopes: [],
+        plan: normalizePlan(repoInfo.owner?.plan?.name ?? repoInfo.plan?.name),
+    };
+    try {
+        const { stdout } = await runGh(['api', `repos/${repo}/contents/.github/workflows`]);
+        const workflows = JSON.parse(stdout);
+        const files = Array.isArray(workflows) ? workflows : [workflows];
+        context.workflowFiles = files
+            .map((f) => f?.name ?? '')
+            .filter((name) => /\.ya?ml$/i.test(name));
+    }
+    catch {
+        context.workflowFiles = [];
+    }
+    try {
+        await runGh(['api', `repos/${repo}/pages`]);
+        context.pagesEnabled = true;
+    }
+    catch {
+        context.pagesEnabled = false;
+    }
+    try {
+        await runGh(['api', `repos/${repo}/code-scanning/alerts`, '-f', 'per_page=1']);
+        context.hasCodeScanning = true;
+    }
+    catch {
+        context.hasCodeScanning = false;
+    }
+    try {
+        const { stdout, stderr } = await runGh(['auth', 'status']);
+        context.tokenScopes = parseScopes(`${stdout}\n${stderr}`);
+    }
+    catch {
+        context.tokenScopes = [];
+    }
+    return context;
+}