@knowttl/gitea-axi 0.0.0-stage → 0.1.1

package/dist/pulls.js

@@ -0,0 +1,299 @@
+import { collect, object, read } from './api.js';
+import { CliError } from './error.js';
+const usage = (message) => { throw new CliError('USAGE', message, 2); };
+const gap = (message) => { throw new CliError('CAPABILITY_GAP', message); };
+const names = (value) => value === undefined ? [] : [...new Set((Array.isArray(value) ? value : [value]).map(String))];
+const sorted = (values) => [...values].sort();
+const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const delta = (previous, add, remove) => [...new Set([...previous.map(String), ...names(add)])].filter(value => !names(remove).includes(value));
+const members = (pull, field, key) => (pull[field] ?? []).map(row => object(row)[key]);
+export function validatePull(operation, options) {
+    if (operation === 'pr review') {
+        if (['approve', 'request-changes', 'comment'].filter(key => options[key]).length !== 1)
+            usage('Choose exactly one of --approve, --request-changes or --comment');
+        gap('C043 unresolved: review wire events and atomic stale-head refusal lack vendor evidence; no review will be posted, including with --match-head-commit');
+    }
+    if (operation === 'pr merge') {
+        const styles = ['merge', 'squash', 'rebase'].filter(key => options[key]);
+        if (styles.length + Number(options.method !== undefined) !== 1)
+            usage('Choose exactly one of --method, --merge, --squash or --rebase');
+        if (!['merge', 'squash', 'rebase'].includes(String(options.method ?? styles[0])))
+            usage('Supported merge methods: merge, squash, rebase');
+        if (!/^[a-f0-9]{40}$/.test(String(options['match-head-commit'] ?? '')))
+            usage('--match-head-commit requires the full 40-character head SHA');
+    }
+}
+function fields(pull) {
+    return { title: pull.title, body: pull.body ?? '', state: pull.state, head: object(pull.head).ref, base: object(pull.base).ref,
+        assignees: sorted(members(pull, 'assignees', 'login')), labels: sorted(members(pull, 'labels', 'id')),
+        milestone: pull.milestone == null ? null : object(pull.milestone).id,
+        reviewers: sorted(members(pull, 'requested_reviewers', 'login')), teams: sorted(members(pull, 'requested_reviewers_teams', 'name')) };
+}
+export async function pullPlan(client, operation, base, number, options) {
+    const action = operation.split(' ')[1];
+    const path = base + '/pulls' + (number ? '/' + number : '');
+    const steps = [];
+    const preconditions = {};
+    const reads = new Set();
+    const snapshot = async (path, list = false) => {
+        let value;
+        if (list) {
+            const page = await collect(client, path);
+            if (page.truncated)
+                throw new CliError('INCOMPLETE_READ', 'A complete collection is required before writing');
+            value = page.items;
+        }
+        else
+            value = await read(client, path);
+        preconditions[path] = value;
+        reads.add(path);
+        return value;
+    };
+    const add = (method, path, payload) => steps.push({ method, path, ...(payload === undefined ? {} : { payload }) });
+    const before = action === 'create' ? undefined : object(await snapshot(path));
+    const expected = before ? { id: before.id, number: before.number, ...fields(before), merged: before.merged ?? false, headSHA: object(before.head).sha } :
+        { title: '', body: '', state: 'open', merged: false, assignees: [], labels: [], milestone: null, reviewers: [], teams: [] };
+    if (action === 'create')
+        await snapshot(path + '?state=all', true);
+    if (action === 'create' || action === 'edit') {
+        for (const [flag, collection, key] of [['assignee', 'assignees', 'login'], ['team-reviewer', 'teams', 'name']]) {
+            const requested = action === 'create' ? names(options[flag]) : [...names(options['add-' + flag]), ...names(options['remove-' + flag])];
+            if (!requested.length)
+                continue;
+            const available = await snapshot(base + '/' + collection, true);
+            for (const name of requested) {
+                const selected = available.find(row => row[key] === name);
+                if (!selected)
+                    usage('Unknown exact ' + flag + ' name: ' + name);
+            }
+        }
+        const addedReviewers = names(action === 'create' ? options.reviewer : options['add-reviewer']);
+        const requestedReviewers = [...new Set([...addedReviewers, ...names(options['remove-reviewer'])])];
+        if (requestedReviewers.length) {
+            const author = object(action === 'create' ? await snapshot('/api/v1/user') : before.user);
+            for (const name of requestedReviewers) {
+                let reviewer;
+                try {
+                    reviewer = object(await snapshot('/api/v1/users/' + encodeURIComponent(name)));
+                }
+                catch (error) {
+                    if (error instanceof CliError && error.code === 'NOT_FOUND_OR_HIDDEN')
+                        usage('Unknown exact reviewer name: ' + name);
+                    throw error;
+                }
+                if (reviewer.login !== name)
+                    usage('Unknown exact reviewer name: ' + name);
+                if (addedReviewers.includes(name) && reviewer.id === author.id)
+                    usage('The PR author cannot be requested as a reviewer');
+            }
+        }
+        const payload = {};
+        for (const field of ['title', 'body', 'base'])
+            if (options[field] !== undefined)
+                payload[field] = options[field];
+        if (action === 'create') {
+            for (const field of ['title', 'base', 'head'])
+                if (!options[field])
+                    usage('--' + field + ' is required');
+            if (String(options.head).includes(':'))
+                gap('Cross-repository PR creation requires separate head repository verification');
+            payload.head = options.head;
+            payload.assignees = names(options.assignee);
+            expected.reviewers = sorted(addedReviewers);
+            expected.teams = sorted(names(options['team-reviewer']));
+            const head = object(await snapshot(base + '/branches/' + encodeURIComponent(String(options.head))));
+            expected.headSHA = object(head.commit).id;
+        }
+        else {
+            if (options['add-assignee'] !== undefined || options['remove-assignee'] !== undefined)
+                payload.assignees = delta(expected.assignees, options['add-assignee'], options['remove-assignee']);
+        }
+        if (options.base !== undefined)
+            await snapshot(base + '/branches/' + encodeURIComponent(String(options.base)));
+        if (options.milestone !== undefined) {
+            const list = await snapshot(base + '/milestones?state=all', true);
+            const selected = list.find(row => row.title === options.milestone);
+            if (!selected)
+                usage('Unknown exact milestone title');
+            payload.milestone = selected.id;
+        }
+        if (options.label !== undefined || options['add-label'] !== undefined || options['remove-label'] !== undefined) {
+            const labels = await snapshot(base + '/labels', true);
+            const ids = (value) => names(value).map(name => {
+                const label = labels.find(row => row.name === name);
+                if (!label)
+                    return usage('Unknown exact label name: ' + name);
+                return label.id;
+            });
+            payload.labels = action === 'create' ? ids(options.label) : [...new Set([...expected.labels, ...ids(options['add-label'])])].filter(id => !ids(options['remove-label']).includes(id));
+        }
+        for (const field of ['title', 'body', 'base', 'head', 'assignees', 'labels', 'milestone'])
+            if (payload[field] !== undefined)
+                expected[field] = payload[field];
+        if (action === 'create') {
+            add('POST', path, payload);
+            if (addedReviewers.length || names(options['team-reviewer']).length)
+                steps.push({ method: 'POST', path: path + '/0/requested_reviewers',
+                    payload: { reviewers: addedReviewers, team_reviewers: names(options['team-reviewer']) }, createdPull: true });
+        }
+        else {
+            for (const [flag, field, wire] of [['reviewer', 'reviewers', 'reviewers'], ['team-reviewer', 'teams', 'team_reviewers']]) {
+                const previous = expected[field];
+                const next = delta(previous, options['add-' + flag], options['remove-' + flag]);
+                const added = next.filter(name => !previous.includes(name));
+                const removed = previous.filter(name => !next.includes(String(name)));
+                if (added.length)
+                    add('POST', path + '/requested_reviewers', { [wire]: added });
+                if (removed.length)
+                    add('DELETE', path + '/requested_reviewers', { [wire]: removed });
+                expected[field] = next;
+            }
+            if (Object.keys(payload).length)
+                add('PATCH', path, payload);
+        }
+        if (!steps.length && !options.attach)
+            usage('Choose a PR field or membership to edit');
+    }
+    else if (action === 'close' || action === 'reopen') {
+        expected.state = action === 'close' ? 'closed' : 'open';
+        add('PATCH', path, { state: expected.state });
+    }
+    else if (action === 'merge') {
+        if (expected.headSHA !== options['match-head-commit'])
+            throw new CliError('STALE_HEAD', 'Selected PR head differs from --match-head-commit');
+        if (before.state !== 'open' || before.merged)
+            usage('Select an open unmerged PR');
+        const style = options.method ?? ['merge', 'squash', 'rebase'].find(key => options[key]);
+        const payload = { Do: style, head_commit_id: options['match-head-commit'] };
+        if (options.subject !== undefined)
+            payload.MergeTitleField = options.subject;
+        if (options.body !== undefined)
+            payload.MergeMessageField = options.body;
+        if (style === 'rebase')
+            await snapshot(path + '/commits', true);
+        await snapshot(base + '/branches/' + encodeURIComponent(String(expected.base)));
+        add('POST', path + '/merge', payload);
+        expected.state = 'closed';
+    }
+    else if (action === 'update-branch') {
+        await snapshot(base + '/branches/' + encodeURIComponent(String(expected.base)));
+        add('POST', path + '/update');
+    }
+    if (action === 'comment' || action === 'close' && options.comment !== undefined) {
+        const body = action === 'comment' ? options.body : options.comment;
+        if (body === undefined || body === '')
+            usage('--body is required');
+        const comments = base + '/issues/' + number + '/comments';
+        await snapshot(comments, true);
+        add('POST', comments, { body });
+    }
+    return { target: path, steps, reads: [...reads], preconditions, pull: { expected, action, repository: base } };
+}
+export async function verifyPull(client, plan, results, observations) {
+    const { expected, action, repository: base } = plan.pull;
+    const before = object(plan.preconditions);
+    const mismatch = () => { throw new CliError('READBACK_MISMATCH', 'PR read-back did not confirm identity, requested fields or commit graph'); };
+    const observation = (path) => observations.find(row => row.path === path)?.data;
+    let pull;
+    if (action === 'create') {
+        const result = object(results[0]);
+        pull = observation(plan.target + '?state=all').find(row => row.id === result.id && row.number === result.number) ?? mismatch();
+        if (before[plan.target + '?state=all'].some(row => row.id === pull.id || row.number === pull.number))
+            mismatch();
+    }
+    else {
+        pull = object(observation(plan.target));
+        if (pull.id !== expected.id || pull.number !== expected.number)
+            mismatch();
+    }
+    const actual = fields(pull);
+    for (const field of Object.keys(actual)) {
+        const value = ['assignees', 'labels', 'reviewers', 'teams'].includes(field) ? sorted(expected[field]) : expected[field];
+        if (!equal(actual[field], value))
+            mismatch();
+    }
+    if (action !== 'update-branch' && object(pull.head).sha !== expected.headSHA)
+        mismatch();
+    if (action !== 'merge' && (pull.merged ?? false) !== expected.merged)
+        mismatch();
+    for (const [index, step] of plan.steps.entries()) {
+        if (!step.path.endsWith('/comments'))
+            continue;
+        const comments = observation(step.path);
+        const previous = before[step.path];
+        const id = object(results[index]).id;
+        const added = comments.filter(row => !previous.some(old => old.id === row.id));
+        if (added.length !== 1 || added[0].id !== id || added[0].body !== object(step.payload).body || previous.some(old => !comments.some(row => equal(row, old))))
+            mismatch();
+    }
+    if (action !== 'merge' && action !== 'update-branch')
+        return;
+    const branchPath = base + '/branches/' + encodeURIComponent(String(expected.base));
+    const baseSHA = object(object(before[branchPath]).commit).id;
+    const commit = async (sha) => {
+        if (typeof sha !== 'string' || !/^[a-f0-9]{40}$/.test(sha))
+            return mismatch();
+        const path = base + '/git/commits/' + sha;
+        const data = object(await read(client, path));
+        if (data.sha !== sha || !Array.isArray(data.parents))
+            mismatch();
+        observations.push({ path, data });
+        return data;
+    };
+    if (action === 'update-branch') {
+        const head = await commit(object(pull.head).sha);
+        const pending = [head], visited = new Set();
+        while (pending.length && visited.size < 1000) {
+            const current = pending.pop();
+            if (visited.has(current.sha))
+                continue;
+            visited.add(current.sha);
+            if (visited.has(baseSHA) && visited.has(expected.headSHA))
+                return;
+            for (const parent of members(current, 'parents', 'sha')) {
+                if (!visited.has(parent))
+                    pending.push(await commit(parent));
+            }
+        }
+        mismatch();
+    }
+    if (pull.merged !== true || !pull.merge_commit_sha)
+        mismatch();
+    const finalSHA = object(object(observation(branchPath)).commit).id;
+    if (finalSHA !== pull.merge_commit_sha)
+        mismatch();
+    const final = await commit(finalSHA);
+    const style = object(plan.steps[0].payload).Do;
+    if (style === 'merge') {
+        if (!equal(members(final, 'parents', 'sha'), [baseSHA, expected.headSHA]))
+            mismatch();
+    }
+    else if (style === 'squash') {
+        if (!equal(members(final, 'parents', 'sha'), [baseSHA]) || finalSHA === expected.headSHA)
+            mismatch();
+    }
+    else {
+        const originals = before[plan.target + '/commits'];
+        if (!originals.length)
+            mismatch();
+        const bySHA = new Map(originals.map(row => [row.sha, row]));
+        let original = bySHA.get(expected.headSHA);
+        let current = final;
+        for (let index = 0; index < originals.length; index++) {
+            const parents = members(current, 'parents', 'sha');
+            if (!original || parents.length !== 1 || object(current.commit).message !== object(original.commit).message)
+                mismatch();
+            if (index === originals.length - 1) {
+                if (parents[0] !== baseSHA)
+                    mismatch();
+            }
+            else {
+                const originalParents = members(original, 'parents', 'sha');
+                if (originalParents.length !== 1)
+                    mismatch();
+                original = bySHA.get(originalParents[0]);
+                current = await commit(parents[0]);
+            }
+        }
+    }
+}

package/dist/reads.js

@@ -0,0 +1,236 @@
+import { execFileSync } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { CliError } from './error.js';
+import { collect, object, read } from './api.js';
+const scalarFields = {
+    additions: 'additions', body: 'body', changedFiles: 'changed_files', closedAt: 'closed_at', createdAt: 'created_at',
+    deletions: 'deletions', fullDatabaseId: 'id', isDraft: 'draft', maintainerCanModify: 'allow_maintainer_edit',
+    mergedAt: 'merged_at', number: 'number', title: 'title', updatedAt: 'updated_at', url: 'html_url',
+};
+const gaps = ['autoMergeRequest', 'closingIssuesReferences', 'id', 'mergeStateStatus', 'potentialMergeCommit', 'projectCards', 'projectItems', 'reviewDecision'];
+export const prFields = [...Object.keys(scalarFields), ...gaps, 'assignees', 'author', 'baseRefName', 'baseRefOid', 'closed', 'comments', 'commits', 'files',
+    'headRefName', 'headRefOid', 'headRepository', 'headRepositoryOwner', 'isCrossRepository', 'labels', 'latestReviews', 'mergeCommit',
+    'mergeable', 'mergedBy', 'milestone', 'reactionGroups', 'reviewRequests', 'reviews', 'state', 'statusCheckRollup'];
+export const issueFields = ['number', 'title', 'state', 'body', 'author', 'assignees', 'labels', 'milestone', 'createdAt', 'updatedAt', 'url'];
+export function selectedFields(options, allowed, unavailable = gaps) {
+    if (typeof options.fields !== 'string')
+        return;
+    const fields = options.fields.split(',');
+    if (fields.some(field => !allowed.includes(field)) || new Set(fields).size !== fields.length)
+        throw new CliError('USAGE', 'Unknown or repeated field; choose ' + allowed.join(','), 2);
+    const gap = fields.find(field => unavailable.includes(field));
+    if (gap)
+        throw new CliError('CAPABILITY_GAP', gap + ' has no evidenced Gitea 1.23.4 equivalent' + (gap === 'id' ? '; fullDatabaseId is the numeric vendor ID, not a GraphQL node ID' : ''));
+    if (options.full || options.comments || options.reviews || options.checks)
+        throw new CliError('USAGE', '--fields cannot combine with --full, --comments, --reviews or --checks', 2);
+    return fields;
+}
+export function positive(value, fallback, maximum) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'string' || !/^\d+$/.test(value) || Number(value) < 1 || Number(value) > maximum)
+        throw new CliError('USAGE', 'Expected a positive integer up to ' + maximum, 2);
+    return Number(value);
+}
+export function repository(explicit, origin) {
+    if (typeof explicit === 'string') {
+        if (!/^[A-Za-z0-9_][A-Za-z0-9_.-]*\/[A-Za-z0-9_][A-Za-z0-9_.-]*$/.test(explicit))
+            throw new CliError('USAGE', '--repo must be OWNER/NAME', 2);
+        return explicit;
+    }
+    if (process.env.GITEA_AXI_PROFILE === 'artium')
+        throw new CliError('USAGE', 'Hosted calls require --repo OWNER/NAME', 2);
+    let remote;
+    try {
+        remote = execFileSync('git', ['config', '--get', 'remote.origin.url'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    }
+    catch {
+        throw new CliError('USAGE', 'Select --repo OWNER/NAME or a matching origin remote', 2);
+    }
+    let url;
+    try {
+        url = new URL(remote.replace(/^git@([^:]+):(.+)$/, 'ssh://git@$1/$2'));
+    }
+    catch {
+        throw new CliError('USAGE', 'Remote must identify a Gitea host; use --repo', 2);
+    }
+    const target = new URL(origin);
+    if (url.hostname !== target.hostname || (url.port && url.port !== target.port))
+        throw new CliError('USAGE', 'Remote host does not match the selected credential origin; use --repo', 2);
+    return repository(url.pathname.slice(1).replace(/\.git$/, ''), origin);
+}
+const user = (value) => value == null ? null : { login: object(value).login, name: object(value).full_name ?? null };
+const users = (value) => value == null ? [] : value.map(user);
+const label = (value) => { const row = object(value); return { name: row.name, color: row.color, description: row.description ?? null }; };
+function preview(body, full) {
+    const text = typeof body === 'string' ? body : '';
+    return full || text.length <= 1000 ? text : text.slice(0, 1000) + `... (truncated, ${text.length} chars total; use --full)`;
+}
+export function issue(row, full = false) {
+    return { number: row.number, title: row.title, state: row.state, body: preview(row.body, full), author: user(row.user),
+        assignees: users(row.assignees), labels: (row.labels ?? []).map(label), milestone: row.milestone == null ? null : { title: object(row.milestone).title },
+        createdAt: row.created_at ?? null, updatedAt: row.updated_at ?? null, url: row.html_url ?? null };
+}
+export function listOptions(options) {
+    const limit = positive(options.limit, 30, 1000);
+    if (options.state !== undefined && !['open', 'closed', 'all'].includes(String(options.state)))
+        throw new CliError('USAGE', '--state must be open, closed or all', 2);
+    if (options.sort !== undefined && !['created', 'updated', 'number', 'comments'].includes(String(options.sort)))
+        throw new CliError('USAGE', 'Unsupported --sort', 2);
+    if (options.order !== undefined && !['asc', 'desc'].includes(String(options.order)))
+        throw new CliError('USAGE', '--order must be asc or desc', 2);
+    return limit;
+}
+export async function listIssues(client, base, kind, options) {
+    const limit = listOptions(options);
+    const fields = selectedFields(options, kind === 'pr' ? issueFields.concat(['isDraft', 'headRefName', 'baseRefName']) : issueFields) ?? ['number', 'title', 'state'];
+    let milestone;
+    if (typeof options.milestone === 'string') {
+        const page = await collect(client, base + '/milestones?state=all');
+        milestone = page.items.find(row => row.title === options.milestone)?.id;
+        if (milestone === undefined)
+            throw new CliError('USAGE', 'Unknown milestone name', 2);
+    }
+    const page = await collect(client, base + (kind === 'pr' ? '/pulls' : '/issues') + '?state=all' + (kind === 'issue' ? '&type=issues' : ''));
+    const rows = page.items.filter(row => (kind !== 'issue' || !row.pull_request) &&
+        (options.state === 'all' || row.state === (options.state ?? 'open')) &&
+        (!options.author || (row.user && object(row.user).login === options.author)) &&
+        (!options.assignee || (row.assignees ?? []).some(item => item.login === options.assignee)) &&
+        (!options.label || (row.labels ?? []).some(item => item.name === options.label)) &&
+        (milestone === undefined || (row.milestone && object(row.milestone).id === milestone)));
+    const sort = options.sort === 'number' ? 'number' : options.sort === 'comments' ? 'comments' : options.sort === 'updated' ? 'updated_at' : 'created_at';
+    rows.sort((a, b) => {
+        const left = a[sort] ?? '', right = b[sort] ?? '';
+        const comparison = typeof left === 'number' && typeof right === 'number' ? left - right : String(left).localeCompare(String(right));
+        return (comparison || Number(a.number) - Number(b.number)) * (options.order === 'asc' ? 1 : -1);
+    });
+    return { items: rows.slice(0, limit).map(row => {
+            const projection = { ...issue(row), isDraft: row.draft ?? null, headRefName: row.head ? object(row.head).ref : null, baseRefName: row.base ? object(row.base).ref : null };
+            return Object.fromEntries(fields.map(field => [field, projection[field]]));
+        }), count: Math.min(rows.length, limit), total: page.truncated ? null : rows.length, unfiltered_total: page.total,
+        truncated: page.truncated || rows.length > limit, next: page.next, continuation: page.truncated || rows.length > limit,
+        help: [`gitea-axi ${kind} view <number> --repo ${base.split('/').slice(-2).join('/')}`, ...continuationHelp(page, rows.length, limit)] };
+}
+async function complete(client, path) {
+    const page = await collect(client, path);
+    if (page.truncated)
+        throw new CliError('RESPONSE_LIMIT', 'Related collection exceeds the bounded read; use the raw API to page explicitly');
+    return page.items;
+}
+async function reviews(client, path, full) {
+    const rows = await complete(client, path + '/reviews');
+    const result = [];
+    for (const row of rows) {
+        const comments = await complete(client, path + '/reviews/' + row.id + '/comments');
+        result.push({ id: row.id, author: user(row.user), state: row.state, dismissed: row.dismissed ?? false, stale: row.stale ?? false, body: preview(row.body, full), commit: { oid: row.commit_id },
+            submittedAt: row.submitted_at ?? null, comments: comments.map(comment => ({ id: comment.id, body: preview(comment.body, full), path: comment.path, position: comment.position, commit: { oid: comment.commit_id } })) });
+    }
+    return result;
+}
+export async function checks(client, base, sha) {
+    const combined = object(await read(client, base + '/commits/' + encodeURIComponent(sha) + '/status'));
+    if (combined.sha !== sha && !(combined.sha === '' && combined.total_count === 0 && (combined.statuses === null || Array.isArray(combined.statuses) && !combined.statuses.length)))
+        throw new CliError('INVALID_RESPONSE', 'Check response does not match the pull request head SHA');
+    const statuses = await complete(client, base + '/commits/' + encodeURIComponent(sha) + '/statuses');
+    statuses.sort((a, b) => Number(b.id) - Number(a.id));
+    const latest = new Map();
+    for (const status of statuses)
+        if (!latest.has(status.context))
+            latest.set(status.context, status);
+    const items = [...latest.values()].map(row => ({ name: row.context, state: row.status, description: row.description ?? null, url: row.target_url ?? null }));
+    const passed = items.filter(row => row.state === 'success').length;
+    const failed = items.filter(row => ['failure', 'error'].includes(String(row.state))).length;
+    const pending = items.length - passed - failed;
+    return { head: sha, items, passed, failed, pending, exitCode: !items.length || failed ? 1 : pending ? 8 : 0 };
+}
+export async function watchChecks(client, base, number, options) {
+    const seconds = positive(options.timeout, 30, 3600);
+    const interval = positive(options.interval, 5, 60) * 1000;
+    const stop = Date.now() + seconds * 1000;
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    process.once('SIGINT', cancel);
+    process.once('SIGTERM', cancel);
+    try {
+        while (true) {
+            const pull = object(await read(client, base + '/pulls/' + number));
+            const sha = object(pull.head).sha;
+            if (typeof sha !== 'string' || !sha)
+                throw new CliError('INVALID_RESPONSE', 'Pull request head SHA is missing');
+            const result = await checks(client, base, sha);
+            if (!options.watch || result.items.length > 0 && !result.pending || result.failed || Date.now() >= stop || controller.signal.aborted)
+                return { ...result, cancelled: controller.signal.aborted };
+            await delay(Math.min(interval, Math.max(1, stop - Date.now())), undefined, { signal: controller.signal }).catch(error => {
+                if (!controller.signal.aborted)
+                    throw error;
+            });
+            if (Date.now() >= stop || controller.signal.aborted)
+                return { ...result, cancelled: controller.signal.aborted };
+        }
+    }
+    finally {
+        process.removeListener('SIGINT', cancel);
+        process.removeListener('SIGTERM', cancel);
+    }
+}
+export async function view(client, base, kind, number, options) {
+    const fields = selectedFields(options, kind === 'pr' ? prFields : issueFields);
+    const path = base + (kind === 'pr' ? '/pulls/' : '/issues/') + number;
+    const row = object(await read(client, path));
+    if (row.number !== Number(number))
+        throw new CliError('INVALID_RESPONSE', 'Response number does not match the selected item');
+    const result = issue(row, Boolean(options.full || fields));
+    const requested = new Set(fields ?? []);
+    if (options.comments || requested.has('comments'))
+        result.comments = (await complete(client, base + '/issues/' + number + '/comments')).map(comment => ({ id: comment.id, author: user(comment.user), body: preview(comment.body, Boolean(options.full || fields)), createdAt: comment.created_at ?? null }));
+    if (kind === 'pr') {
+        const head = object(row.head), tail = object(row.base);
+        if (typeof head.sha !== 'string' || !head.sha)
+            throw new CliError('INVALID_RESPONSE', 'Pull request head SHA is missing');
+        Object.assign(result, { headRefOid: head.sha, headRefName: head.ref ?? null, baseRefOid: tail.sha ?? null, baseRefName: tail.ref ?? null, isDraft: row.draft ?? null });
+        if (fields) {
+            for (const [field, key] of Object.entries(scalarFields))
+                if (requested.has(field))
+                    result[field] = row[key] ?? null;
+            Object.assign(result, { closed: row.state === 'closed' || row.merged === true, state: row.merged ? 'MERGED' : String(row.state).toUpperCase(),
+                headRepository: head.repo == null ? null : { name: object(head.repo).name, nameWithOwner: object(head.repo).full_name },
+                headRepositoryOwner: head.repo == null ? null : user(object(head.repo).owner), isCrossRepository: head.repo_id == null || tail.repo_id == null ? null : head.repo_id !== tail.repo_id,
+                mergeCommit: row.merge_commit_sha ? { oid: row.merge_commit_sha } : null, mergedBy: user(row.merged_by),
+                mergeable: row.mergeable == null ? 'UNKNOWN' : row.mergeable ? 'MERGEABLE' : 'CONFLICTING', reviewRequests: users(row.requested_reviewers) });
+        }
+        if (options.reviews || requested.has('reviews') || requested.has('latestReviews')) {
+            const all = await reviews(client, path, Boolean(options.full || fields));
+            result.reviews = all;
+            if (requested.has('latestReviews')) {
+                const latest = new Map();
+                for (const review of [...all].sort((a, b) => Number(a.id) - Number(b.id)))
+                    latest.set(review.author?.login, review);
+                result.latestReviews = [...latest.values()];
+            }
+        }
+        if (options.checks || requested.has('statusCheckRollup'))
+            result.statusCheckRollup = { ...await checks(client, base, head.sha), source: 'commit-statuses', partial: true };
+        if (requested.has('commits'))
+            result.commits = (await complete(client, path + '/commits')).map(commit => ({ oid: commit.sha, message: object(commit.commit).message }));
+        if (requested.has('files'))
+            result.files = (await complete(client, path + '/files')).map(file => ({ path: file.filename, additions: file.additions, deletions: file.deletions, status: file.status }));
+        if (requested.has('reactionGroups')) {
+            const groups = new Map();
+            for (const reaction of await complete(client, base + '/issues/' + number + '/reactions'))
+                groups.set(reaction.content, [...(groups.get(reaction.content) ?? []), reaction]);
+            result.reactionGroups = [...groups].map(([content, reactions]) => ({ content, users: { totalCount: reactions.length } }));
+        }
+    }
+    return fields ? Object.fromEntries(fields.map(field => [field, result[field] ?? null])) : result;
+}
+export function continuationHelp(page, count, limit) {
+    if (!page.truncated && count <= limit)
+        return [];
+    return [page.truncated ? 'Use gitea-axi api GET "<collection>?limit=50&page=<page>" to page beyond the bounded read (maximum 1000 items).' : 'Raise --limit to see more items (maximum 1000).'];
+}
+export function boundedList(page, limit, fields) {
+    return { items: page.items.slice(0, limit).map(row => Object.fromEntries(fields.map(key => [key, row[key] ?? null]))),
+        count: Math.min(page.items.length, limit), total: page.total, next: page.next,
+        truncated: page.truncated || page.items.length > limit, continuation: page.truncated || page.items.length > limit,
+        ...(continuationHelp(page, page.items.length, limit).length ? { help: continuationHelp(page, page.items.length, limit) } : {}) };
+}