tinybeeai 0.0.0-stage → 0.16.1

package/dist/integrations/github-issues.js

@@ -0,0 +1,705 @@
+// GitHub Issues as a tracker (docs/TRACKERS.md section GitHub Issues, design section 4).
+// The normalizer turns `issues` and `issue_comment.created` deliveries, and the poller's rows,
+// into ticket_created and ticket_updated events. Scope (labels, issue types, milestones) is
+// per dot, so the normalizer emits every candidate and watchMatches decides through issueInScope.
+import { createHash } from 'node:crypto';
+import { liveEnv } from '../config.js';
+import { findOne, get, insert, update } from '../db.js';
+import { extractAcceptanceCriteria } from './adf.js';
+import { hasLegacyDefectMarker, hasValidBotMarker, withBotMarker } from './bot-marker.js';
+import { isOwnId } from './own-identity.js';
+import { apiBase, isDefectLabel, githubMode, githubTokenFor, headers, selfLogin } from './github.js';
+import { watchRepos } from '../repos.js';
+import { backfillLimitError } from '../monitor/backfill.js';
+/** Marks the localdost review comment on an issue. A re-review edits that comment in place. */
+export const TICKET_REVIEW_MARKER = '<!-- localdost:ticket-review -->';
+/** A comment that starts a line with this asks for a review now. */
+export const REVIEW_COMMAND = /^\s*\/(?:localdost|qadots)\s+review\b/im;
+/** Used when the dot's tracker sets no labels or types. Issue types win over labels when an issue has one. */
+export const DEFAULT_LABELS = { requirement: ['requirement', 'story', 'feature', 'enhancement'], defect: ['bug', 'defect'], ignore: [] };
+export const DEFAULT_ISSUE_TYPES = { requirement: ['Feature', 'Story', 'Task'], defect: ['Bug'] };
+/** A label name is at most 50 characters on GitHub. */
+export const LABEL_MAX = 50;
+/** Required labels a tracker may list. */
+export const REQUIRE_LABELS_MAX = 20;
+/**
+ * Checks `tracker.labels.require` in a dot save: a list of label names. Returns the message to answer, or null.
+ * Only a GitHub tracker has the label field; every tracker may carry `backfillLimit`.
+ */
+export function trackerScopeError(tracker) {
+    if (tracker === undefined || tracker === null)
+        return null;
+    if (typeof tracker !== 'object' || Array.isArray(tracker))
+        return 'tracker must be an object.';
+    const t = tracker;
+    const limit = backfillLimitError(t.backfillLimit);
+    if (limit)
+        return limit;
+    if (t.kind !== 'github' || t.labels === undefined)
+        return null;
+    if (t.labels === null || typeof t.labels !== 'object' || Array.isArray(t.labels))
+        return 'tracker.labels must be an object.';
+    const required = t.labels.require;
+    if (required === undefined)
+        return null;
+    const bad = `tracker.labels.require must be a list of label names (up to ${REQUIRE_LABELS_MAX}, each up to ${LABEL_MAX} characters).`;
+    if (!Array.isArray(required) || required.length > REQUIRE_LABELS_MAX)
+        return bad;
+    for (const l of required)
+        if (typeof l !== 'string' || !l.trim() || l.trim().length > LABEL_MAX || /[\r\n]/.test(l))
+            return bad;
+    return null;
+}
+/** The saved tracker: required labels trimmed and without repeats (any case), and the key dropped when none are left. */
+export function tidyTrackerScope(tracker) {
+    const t = tracker;
+    if (t?.kind !== 'github' || !t.labels || !Array.isArray(t.labels.require))
+        return tracker;
+    const seen = new Set();
+    const required = t.labels.require.map((l) => l.trim()).filter((l) => l && !seen.has(l.toLowerCase()) && !!seen.add(l.toLowerCase()));
+    const labels = { ...t.labels };
+    if (required.length)
+        labels.require = required;
+    else
+        delete labels.require;
+    const out = { ...t, labels };
+    if (!Object.keys(labels).length)
+        delete out.labels;
+    return out;
+}
+/** The first required label of a GitHub tracker, as written ("pod:agentic"), or undefined when the tracker requires none. */
+export function requiredLabel(w) {
+    const t = w.tracker;
+    return t?.kind === 'github' ? t.labels?.require?.map((l) => l.trim()).find(Boolean) : undefined;
+}
+/**
+ * The scope settings a classifier reads for a dot. A GitHub tracker has its own. A Jira, Linear or tracker-less dot has
+ * none and keeps Feature and Story as its requirement types: a Task is a chore there. Only a GitHub tracker takes Task
+ * by default (KAT-353).
+ */
+export function classifierTracker(w) {
+    return w.tracker?.kind === 'github' ? w.tracker : { kind: 'github', issueTypes: { requirement: ['Feature', 'Story'] } };
+}
+/** The first defect label of a GitHub tracker as written (default `bug`). */
+export function trackerDefectLabel(w) {
+    const t = w.tracker;
+    const first = t?.kind === 'github' ? t.labels?.defect?.find((l) => l.trim()) : undefined;
+    return (first ?? DEFAULT_LABELS.defect[0]).trim();
+}
+/** The first defect issue type of a GitHub tracker (default Bug). */
+export function trackerDefectType(w) {
+    const t = w.tracker;
+    const first = t?.kind === 'github' ? t.issueTypes?.defect?.find((x) => x.trim()) : undefined;
+    return (first ?? DEFAULT_ISSUE_TYPES.defect[0]).trim();
+}
+const lc = (s) => String(s ?? '').toLowerCase();
+const lcList = (xs) => (xs ?? []).map((x) => x.trim().toLowerCase()).filter(Boolean);
+export function issueRef(full, n) {
+    return `${full.toLowerCase()}#${n}`;
+}
+/** "owner/name#12" to its parts; null for anything else. */
+export function parseIssueRef(ref) {
+    const m = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)$/.exec(ref.trim());
+    if (!m)
+        return null;
+    return { full: `${m[1]}/${m[2]}`, owner: m[1], name: m[2], number: Number(m[3]) };
+}
+/** First 16 hex chars of sha256 over title and body. Repeated edits to the same text share it. */
+export function bodyHash(title, body) {
+    return createHash('sha256')
+        .update(`${String(title ?? '')}\n${String(body ?? '')}`)
+        .digest('hex')
+        .slice(0, 16);
+}
+// Acceptance criteria
+const TASK_ITEM = /^\s*[-*]\s+\[[ xX]\]\s+\S/;
+const FORM_AC_LABEL = /acceptance|criteria|definition of done|done when|expected (behaviou?r|result)|success/i;
+/**
+ * Acceptance criteria of an issue body, first match wins: a section under an "Acceptance criteria"
+ * heading, the task list items, or the issue form sections (`### <label>`) whose label names criteria.
+ */
+export function issueAcceptanceCriteria(body) {
+    const fromHeading = extractAcceptanceCriteria(body);
+    if (fromHeading)
+        return fromHeading;
+    const lines = body.split('\n');
+    const tasks = lines.filter((l) => TASK_ITEM.test(l)).map((l) => l.trim());
+    if (tasks.length)
+        return tasks.join('\n');
+    const sections = [];
+    for (let i = 0; i < lines.length; i++) {
+        const h = /^###\s+(.+?)\s*$/.exec(lines[i] ?? '');
+        if (!h || !FORM_AC_LABEL.test(h[1] ?? ''))
+            continue;
+        const out = [];
+        for (let j = i + 1; j < lines.length && !/^#{1,3}\s/.test(lines[j] ?? ''); j++)
+            out.push(lines[j] ?? '');
+        const text = out.join('\n').trim();
+        if (text && text !== '_No response_')
+            sections.push(text);
+    }
+    return sections.length ? sections.join('\n\n') : undefined;
+}
+// Ticket mapping
+function repoOf(payload, issue) {
+    const r = payload.repository;
+    if (r?.full_name)
+        return String(r.full_name);
+    if (r?.owner && r?.name)
+        return `${r.owner.login ?? r.owner.name}/${r.name}`;
+    // GET /issues/{n} has repository_url: https://api.github.com/repos/<owner>/<name>
+    const m = /\/repos\/([^/]+\/[^/]+)$/.exec(String(issue.repository_url ?? ''));
+    return m ? m[1] : '';
+}
+export function issueToTicket(issue, full) {
+    const description = String(issue.body ?? '');
+    const t = {
+        key: `${full}#${issue.number}`,
+        id: String(issue.node_id ?? issue.id ?? issue.number),
+        tracker: 'github',
+        title: String(issue.title ?? ''),
+        description,
+        repo: full,
+        state: issue.state === 'closed' ? 'closed' : 'open',
+    };
+    const ac = issueAcceptanceCriteria(description);
+    if (ac)
+        t.acceptanceCriteria = ac;
+    if (Array.isArray(issue.labels))
+        t.labels = issue.labels.map((l) => String(typeof l === 'string' ? l : l?.name)).filter(Boolean);
+    const type = issue.type?.name ?? (typeof issue.type === 'string' ? issue.type : undefined);
+    if (type) {
+        t.issueType = String(type);
+        t.type = String(type);
+    }
+    if (issue.milestone?.title)
+        t.milestone = String(issue.milestone.title);
+    if (issue.html_url)
+        t.url = String(issue.html_url);
+    if (issue.user?.login)
+        t.reporter = String(issue.user.login);
+    // A card shows an open issue as active, a closed one as done, or as canceled when it was closed as not planned.
+    t.status = issue.state === 'closed' ? (issue.state_reason === 'not_planned' ? 'Closed as not planned' : 'Closed') : 'Open';
+    t.statusKind = issue.state === 'closed' ? (issue.state_reason === 'not_planned' ? 'canceled' : 'done') : 'active';
+    const assignee = issue.assignee?.login ?? (Array.isArray(issue.assignees) ? issue.assignees[0]?.login : undefined);
+    if (assignee)
+        t.assignee = String(assignee);
+    if (issue.updated_at)
+        t.updatedAt = String(issue.updated_at);
+    return t;
+}
+// Scope
+export function trackerRepos(w) {
+    const t = w.tracker;
+    if (t?.kind !== 'github')
+        return [];
+    const repos = lcList(t.repos);
+    if (repos.length)
+        return [...new Set(repos)];
+    // No repos named on the tracker: the dot's app repos (docs/MULTI-REPO.md section 4.1).
+    return watchRepos(w)
+        .filter((r) => r.role === 'app')
+        .map((r) => r.id);
+}
+function scopeLists(t) {
+    const labels = t.labels ?? {};
+    const types = t.issueTypes ?? {};
+    return {
+        reqLabels: labels.requirement?.length ? lcList(labels.requirement) : DEFAULT_LABELS.requirement,
+        defLabels: labels.defect?.length ? lcList(labels.defect) : DEFAULT_LABELS.defect,
+        ignore: lcList(labels.ignore),
+        require: lcList(labels.require),
+        reqTypes: types.requirement?.length ? lcList(types.requirement) : lcList(DEFAULT_ISSUE_TYPES.requirement),
+        defTypes: types.defect?.length ? lcList(types.defect) : lcList(DEFAULT_ISSUE_TYPES.defect),
+    };
+}
+/**
+ * Requirement, defect, or null (skip). An issue with a type is classed by the type alone, so a type
+ * that is neither a requirement nor a defect type is skipped. An issue with no type falls back to its
+ * labels. When the tracker requires labels, an issue with none of them is skipped first, whatever its type,
+ * and an untyped issue that has one is a requirement unless a defect label, or the `localdost` label of the dot's
+ * own defects, says otherwise: the team's label is what marks its issues, and the dot's own defects carry it too.
+ */
+export function issueClass(ticket, t) {
+    const s = scopeLists(t);
+    const labels = lcList(ticket.labels);
+    if (s.require.length && !labels.some((l) => s.require.includes(l)))
+        return null;
+    if (ticket.issueType) {
+        const ty = lc(ticket.issueType);
+        if (s.reqTypes.includes(ty))
+            return 'requirement';
+        if (s.defTypes.includes(ty))
+            return 'defect';
+        return null;
+    }
+    if (labels.some((l) => s.reqLabels.includes(l)))
+        return 'requirement';
+    if (labels.some((l) => s.defLabels.includes(l)))
+        return 'defect';
+    if (!s.require.length)
+        return null;
+    return labels.some(isDefectLabel) ? 'defect' : 'requirement';
+}
+/** The labels as the issue shows them, for a skip reason: `pod:other, bug`, or "no labels". */
+const shown = (labels) => (labels?.length ? labels.join(', ') : 'no labels');
+/**
+ * Why this dot does not review the issue the event names, in plain words, or null when it does. `inScope` tells an
+ * issue the dot skips from an in-scope issue whose event starts nothing, so the log says which. Called from
+ * issueInScope, and so from watchMatches, for GitHub ticket events.
+ */
+export function issueSkip(w, ev) {
+    const out = (why) => ({ why, inScope: false });
+    const t = w.tracker;
+    if (t?.kind !== 'github' || ev.ticket?.tracker !== 'github')
+        return out('the dot has no GitHub tracker');
+    if (!trackerRepos(w).includes(lc(ev.ticket.projectKey)))
+        return out(`${ev.ticket.projectKey} is not one of the tracker repos`);
+    const ticket = ev.inlineTicket;
+    if (!ticket)
+        return out('the event carries no issue');
+    if (ticket.state === 'closed')
+        return out('the issue is closed');
+    const s = scopeLists(t);
+    const labels = lcList(ticket.labels);
+    const ignored = labels.find((l) => s.ignore.includes(l));
+    if (ignored)
+        return out(`it has the skip label "${ignored}"`);
+    const change = ev.ticket.change;
+    // The required label bounds the dot, even for a person who asks by name: the team's Inbox and model budget are theirs.
+    if (s.require.length && !labels.some((l) => s.require.includes(l)))
+        return out(`it has none of the required labels (${(t.labels?.require ?? []).join(', ')}); it has ${shown(ticket.labels)}`);
+    // A person asked by name; an issue that is not ignored and has the required label gets a review, whatever its milestone or class.
+    if (change?.field === 'command')
+        return null;
+    const milestones = lcList(t.milestones);
+    if (milestones.length && !milestones.includes(lc(ticket.milestone)))
+        return out(ticket.milestone
+            ? `milestone "${ticket.milestone}" is not one of ${(t.milestones ?? []).join(', ')}`
+            : `it has no milestone (the dot reviews ${(t.milestones ?? []).join(', ')})`);
+    if (!issueClass(ticket, t))
+        return out(ticket.issueType
+            ? `type "${ticket.issueType}" is not a requirement or defect type`
+            : `it has no issue type and no requirement or defect label; it has ${shown(ticket.labels)}`);
+    // A change counts only when it can bring the issue into scope: a required, requirement or defect label, or a listed type.
+    const event = (why) => ({ why, inScope: true });
+    if (change?.field === 'label' && ![...s.reqLabels, ...s.defLabels, ...s.require].includes(lc(change.value)))
+        return event(`label "${change.value}" does not change the scope`);
+    if (change?.field === 'type' && ![...s.reqTypes, ...s.defTypes].includes(lc(change.value)))
+        return event(`type "${change.value}" is not a requirement or defect type`);
+    if (change?.field === 'milestone' && milestones.length === 0)
+        return event('the dot reviews every milestone, so a milestone change adds nothing');
+    return null;
+}
+/** Does this dot review the issue the event names? Called from watchMatches for GitHub ticket events. */
+export function issueInScope(w, ev) {
+    return issueSkip(w, ev) === null;
+}
+// Normalizer
+/** localdost' own App, or the login set in GITHUB_BOT_LOGIN. */
+function isOwnActor(user, issueOrComment) {
+    const appId = Number(liveEnv.GITHUB_APP_ID);
+    if (appId && Number(issueOrComment?.performed_via_github_app?.id) === appId)
+        return true;
+    const bot = lc(liveEnv.GITHUB_BOT_LOGIN);
+    return !!bot && lc(user?.login) === bot;
+}
+/**
+ * The dot wrote this issue body or comment: its signed marker is in the text AND the author is the dot's
+ * App or the user of its token. A marker pasted by anyone else is ignored. A defect issue that an older
+ * version filed carries only the unsigned defect marker; it counts the same way, by its author.
+ */
+export function isOwnWrite(text, user, issueOrComment) {
+    if (!hasValidBotMarker(text) && !hasLegacyDefectMarker(text))
+        return false;
+    const appId = Number(liveEnv.GITHUB_APP_ID);
+    if (appId && Number(issueOrComment?.performed_via_github_app?.id) === appId)
+        return true;
+    return isOwnId('github', user?.login);
+}
+export function createdKey(full, n) {
+    return `github-issue:${issueRef(full, n)}:created`;
+}
+/**
+ * `issues` and `issue_comment` deliveries to ticket events. Returns null for pull requests, events
+ * that change nothing a review reads, localdost' own issues, and comments without `/localdost review`.
+ * The caller checks the commenter's write access before it dispatches a command.
+ */
+export function normalizeGithubIssue(eventName, payload) {
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const issue = payload.issue;
+    if (!issue?.number || issue.pull_request)
+        return null;
+    const full = repoOf(payload, issue);
+    if (!full)
+        return null;
+    const ticket = issueToTicket(issue, full);
+    if (isOwnWrite(ticket.description, issue.user, issue))
+        return null;
+    const n = Number(issue.number);
+    const hash = bodyHash(issue.title, issue.body);
+    const action = String(payload.action ?? '');
+    let kind = 'ticket_updated';
+    let change;
+    let dedupeKey = `github-issue:${issueRef(full, n)}:edited:${hash.slice(0, 8)}`;
+    if (eventName === 'issues') {
+        switch (action) {
+            case 'opened':
+                if (isOwnActor(issue.user, issue))
+                    return null;
+                kind = 'ticket_created';
+                dedupeKey = createdKey(full, n);
+                break;
+            case 'edited': {
+                const ch = payload.changes ?? {};
+                if (!ch.body && !ch.title)
+                    return null;
+                if (isOwnActor(payload.sender, undefined))
+                    return null;
+                change = { field: ch.body ? 'body' : 'title' };
+                break;
+            }
+            case 'labeled':
+                if (!payload.label?.name)
+                    return null;
+                change = { field: 'label', value: String(payload.label.name) };
+                break;
+            case 'typed':
+                if (!(issue.type?.name ?? payload.type?.name))
+                    return null;
+                change = { field: 'type', value: String(issue.type?.name ?? payload.type?.name) };
+                break;
+            case 'milestoned':
+                if (!(payload.milestone?.title ?? issue.milestone?.title))
+                    return null;
+                change = { field: 'milestone', value: String(payload.milestone?.title ?? issue.milestone?.title) };
+                break;
+            default:
+                return null;
+        }
+    }
+    else if (eventName === 'issue_comment') {
+        const comment = payload.comment;
+        if (action !== 'created' || !comment || !REVIEW_COMMAND.test(String(comment.body ?? '')))
+            return null;
+        if (isOwnWrite(comment.body, comment.user ?? payload.sender, comment))
+            return null;
+        const sender = payload.sender ?? comment.user ?? {};
+        if (sender.type === 'Bot' || /\[bot\]$/.test(String(sender.login ?? '')) || isOwnActor(sender, comment))
+            return null;
+        change = { field: 'command', value: String(sender.login ?? '') };
+        dedupeKey = `github-issue:${issueRef(full, n)}:command:${comment.id ?? Date.now()}`;
+    }
+    else {
+        return null;
+    }
+    return {
+        source: 'github',
+        kind,
+        dedupeKey,
+        title: `${ticket.key}: ${ticket.title}`,
+        ...(ticket.url ? { url: ticket.url } : {}),
+        repo: { owner: full.split('/')[0], name: full.split('/')[1] },
+        ticket: { key: ticket.key, id: ticket.id, tracker: 'github', projectKey: full, bodyHash: hash, ...(change ? { change } : {}) },
+        inlineTicket: ticket,
+    };
+}
+/**
+ * True when this dot already reviewed the same text of the issue. An issue opened with a label fires
+ * `opened` and `labeled` together, in either order; this keeps that to one review.
+ */
+export function reviewedSameBody(watchId, ev) {
+    const t = ev.ticket;
+    if (t?.tracker !== 'github' || t.change?.field === 'command' || !t.bodyHash)
+        return false;
+    if (ev.kind !== 'ticket_updated' && ev.kind !== 'ticket_created')
+        return false;
+    const p = parseIssueRef(t.key);
+    if (!p)
+        return false;
+    const other = ev.kind === 'ticket_updated' ? createdKey(p.full, p.number) : `github-issue:${issueRef(p.full, p.number)}:edited:${t.bodyHash.slice(0, 8)}`;
+    const job = findOne('jobs', { dedupeKey: `${other}:${watchId}:ticket_review` });
+    return !!job && job.payload?.ticket?.bodyHash === t.bodyHash;
+}
+export function scopeSig(issue) {
+    const labels = Array.isArray(issue.labels) ? issue.labels.map((l) => lc(typeof l === 'string' ? l : l?.name)).sort() : [];
+    return JSON.stringify({ labels, type: issue.type?.name ?? null, milestone: issue.milestone?.title ?? null });
+}
+export function issueState(full, n) {
+    return get('issue_state', issueRef(full, n));
+}
+/** Upserts the issue's row. Webhooks call it for every issue event, the poller for every row it reads. */
+export function recordIssue(full, issue) {
+    const id = issueRef(full, issue.number);
+    const row = {
+        repoId: full.toLowerCase(),
+        number: Number(issue.number),
+        title: String(issue.title ?? ''),
+        bodyHash: bodyHash(issue.title, issue.body),
+        scopeSig: scopeSig(issue),
+        state: issue.state === 'closed' ? 'closed' : 'open',
+        updatedAt: String(issue.updated_at ?? new Date().toISOString()),
+    };
+    if (get('issue_state', id))
+        update('issue_state', id, row);
+    else
+        insert('issue_state', { id, ...row });
+    return get('issue_state', id);
+}
+/** Keeps issue_state current from a webhook delivery. Pull requests and other events are ignored. */
+export function recordIssueEvent(payload) {
+    const issue = payload?.issue;
+    if (!issue?.number || issue.pull_request)
+        return;
+    const full = repoOf(payload, issue);
+    if (full)
+        recordIssue(full, issue);
+}
+/** The labels localdost manages for the test status write-back. Nothing else is ever removed. */
+export const STATUS_LABELS = ['qa: passing', 'qa: failing'];
+/** An HTTP failure of the issues API, with the status and the response text for callers that branch on it. */
+export class GithubHttpError extends Error {
+    status;
+    responseText;
+    constructor(message, status, responseText) {
+        super(message);
+        this.status = status;
+        this.responseText = responseText;
+    }
+}
+/** The number names a pull request, not an issue. */
+export class NotAnIssueError extends Error {
+}
+/** True when a 422 names the `type` field: the repo has no issue types, or not this one. */
+function rejectsType(err) {
+    if (!(err instanceof GithubHttpError) || err.status !== 422)
+        return false;
+    try {
+        const parsed = JSON.parse(err.responseText);
+        return (parsed.errors ?? []).some((e) => lc(e.field) === 'type');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * True when a failure may be about the labels: a token that cannot set them (403, 404, 410), or a 422 that
+ * names the labels field or names no field at all. A 422 that names another field (the title) is not retried.
+ */
+function mayBeLabels(err) {
+    if (!(err instanceof GithubHttpError))
+        return false;
+    if ([403, 404, 410].includes(err.status))
+        return true;
+    if (err.status !== 422)
+        return false;
+    try {
+        const fields = (JSON.parse(err.responseText).errors ?? []).map((e) => lc(e.field)).filter(Boolean);
+        return fields.length === 0 || fields.includes('labels');
+    }
+    catch {
+        return true;
+    }
+}
+export function issueApi(full, deps = {}) {
+    const f = deps.fetch ?? fetch;
+    const token = () => (deps.token ?? githubTokenFor)(full);
+    /** One request; `link` is the Link header, which names the last page of a list. */
+    async function request(method, p, body) {
+        const res = await f(`${apiBase()}${p}`, {
+            method,
+            headers: { ...headers(await token()), ...(body ? { 'Content-Type': 'application/json' } : {}) },
+            ...(body ? { body: JSON.stringify(body) } : {}),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new GithubHttpError(`GitHub ${method} ${p.split('?')[0]} failed: HTTP ${res.status} ${text.slice(0, 300)}`, res.status, text);
+        }
+        return { data: (res.status === 204 ? undefined : await res.json()), link: res.headers?.get?.('link') ?? null };
+    }
+    async function call(method, p, body) {
+        return (await request(method, p, body)).data;
+    }
+    /** Number of the open milestone with this title, or undefined. A lookup failure only drops the milestone. */
+    async function milestoneNumber(title) {
+        try {
+            const rows = await call('GET', `/repos/${full}/milestones?state=open&per_page=100`);
+            return rows.find((m) => lc(m.title) === lc(title))?.number;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async function ownComment() {
+        if (deps.login || githubMode() === 'pat') {
+            const login = deps.login ? await deps.login() : await selfLogin(await token());
+            if (login)
+                return (c) => lc(c.user?.login) === lc(login);
+        }
+        const appId = Number(liveEnv.GITHUB_APP_ID);
+        // Comments an App installation writes always carry performed_via_github_app; another bot's comment does not match.
+        return (c) => c.user?.type === 'Bot' && (!appId || Number(c.performed_via_github_app?.id) === appId);
+    }
+    return {
+        async getIssue(n) {
+            const issue = await call('GET', `/repos/${full}/issues/${n}`);
+            if (issue.pull_request)
+                throw new NotAnIssueError(`${full}#${n} is a pull request, not an issue`);
+            return issueToTicket(issue, full);
+        },
+        async createIssue(draft) {
+            // Learn who the dot writes as before the issue exists, so its webhook is recognized as the dot's own.
+            if (githubMode() === 'pat')
+                await selfLogin(await token());
+            const body = { title: draft.title, body: withBotMarker(draft.body) };
+            if (draft.labels?.length)
+                body.labels = draft.labels;
+            if (draft.issueType)
+                body.type = draft.issueType;
+            if (draft.milestone) {
+                const number = await milestoneNumber(draft.milestone);
+                if (number)
+                    body.milestone = number;
+            }
+            // Each failed attempt drops the one field the repo refused, so the loop ends after at most two retries.
+            let issue;
+            for (;;) {
+                try {
+                    issue = await call('POST', `/repos/${full}/issues`, body);
+                    break;
+                }
+                catch (err) {
+                    // A repo without org issue types answers 422 on the type field. Labels still carry the class.
+                    if (body.type && rejectsType(err)) {
+                        delete body.type;
+                        continue;
+                    }
+                    // A token that may not set labels (or a repo that refuses them) gets the issue without them.
+                    if (body.labels && mayBeLabels(err)) {
+                        console.warn(`[github] could not set labels on the new issue: ${err.message}`);
+                        delete body.labels;
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+            return { number: Number(issue.number), url: String(issue.html_url ?? ''), key: `${full}#${issue.number}` };
+        },
+        async findOpenByMarker(marker, needle) {
+            const q = `repo:${full} is:issue is:open in:body ${needle}`;
+            const res = await call('GET', `/search/issues?q=${encodeURIComponent(q)}&per_page=20`);
+            const hit = (res.items ?? []).find((i) => !i.pull_request && String(i.body ?? '').includes(marker));
+            return hit ? { number: Number(hit.number), url: String(hit.html_url ?? '') } : null;
+        },
+        async addComment(n, markdown) {
+            await call('POST', `/repos/${full}/issues/${n}/comments`, { body: withBotMarker(markdown) });
+        },
+        async setState(n, state, reason) {
+            await call('PATCH', `/repos/${full}/issues/${n}`, {
+                state,
+                ...(state === 'closed' && reason ? { state_reason: reason } : state === 'open' ? { state_reason: 'reopened' } : {}),
+            });
+        },
+        async setStatusLabel(n, label) {
+            if (!STATUS_LABELS.includes(label))
+                throw new Error(`not a status label: ${label}`);
+            const have = await call('GET', `/repos/${full}/issues/${n}/labels?per_page=100`);
+            for (const other of STATUS_LABELS.filter((l) => l !== label)) {
+                if (have.some((l) => lc(l.name) === other))
+                    await call('DELETE', `/repos/${full}/issues/${n}/labels/${encodeURIComponent(other)}`);
+            }
+            await call('POST', `/repos/${full}/issues/${n}/labels`, { labels: [label] });
+        },
+        async upsertReviewComment(n, markdown) {
+            const comments = [];
+            for (let page = 1; page <= 10; page++) {
+                const batch = await call('GET', `/repos/${full}/issues/${n}/comments?per_page=100&page=${page}`);
+                comments.push(...batch);
+                if (batch.length < 100)
+                    break;
+            }
+            const mine = await ownComment();
+            const existing = comments.find((c) => String(c.body ?? '').includes(TICKET_REVIEW_MARKER) && mine(c));
+            const body = withBotMarker(markdown.includes(TICKET_REVIEW_MARKER) ? markdown : `${TICKET_REVIEW_MARKER}\n${markdown}`);
+            if (existing)
+                await call('PATCH', `/repos/${full}/issues/comments/${existing.id}`, { body });
+            else
+                await call('POST', `/repos/${full}/issues/${n}/comments`, { body });
+        },
+        async timeline(n) {
+            const out = [];
+            for (let page = 1; page <= 5; page++) {
+                const batch = await call('GET', `/repos/${full}/issues/${n}/timeline?per_page=100&page=${page}`);
+                out.push(...batch);
+                if (batch.length < 100)
+                    break;
+            }
+            return out;
+        },
+        async listComments(n, max = 100) {
+            const path = (page) => `/repos/${full}/issues/${n}/comments?per_page=100&page=${page}`;
+            const first = await request('GET', path(1));
+            const last = Number(/[?&]page=(\d+)[^>]*>;\s*rel="last"/.exec(first.link ?? '')?.[1]) || 1;
+            // Rows come oldest first, so the newest are on the last page: read from there back until `max` rows are in hand.
+            const batches = [];
+            let have = 0;
+            let lastLen = 0;
+            for (let page = last; page >= 1 && have < max; page--) {
+                const batch = page === 1 ? first.data : await call('GET', path(page));
+                if (page === last)
+                    lastLen = batch.length;
+                batches.unshift(batch);
+                have += batch.length;
+            }
+            return { rows: batches.flat().slice(-max).reverse(), total: (last - 1) * 100 + lastLen };
+        },
+        async getParent(n) {
+            try {
+                return await call('GET', `/repos/${full}/issues/${n}/parent`);
+            }
+            catch (err) {
+                if (err instanceof GithubHttpError && err.status === 404)
+                    return null;
+                throw err;
+            }
+        },
+        async listSubIssues(n, max = 30) {
+            try {
+                return await call('GET', `/repos/${full}/issues/${n}/sub_issues?per_page=${Math.min(100, max)}`);
+            }
+            catch (err) {
+                if (err instanceof GithubHttpError && err.status === 404)
+                    return [];
+                throw err;
+            }
+        },
+        async writePermission(login) {
+            if (!login)
+                return false;
+            try {
+                const res = await call('GET', `/repos/${full}/collaborators/${encodeURIComponent(login)}/permission`);
+                return ['admin', 'maintain', 'write'].includes(String(res.permission ?? ''));
+            }
+            catch (err) {
+                return /HTTP 404/.test(String(err)) ? false : null;
+            }
+        },
+        async graphql(query, variables) {
+            const base = apiBase();
+            const url = base.endsWith('/api/v3') ? `${base.replace(/\/v3$/, '')}/graphql` : `${base}/graphql`;
+            const res = await f(url, {
+                method: 'POST',
+                headers: { ...headers(await token()), 'Content-Type': 'application/json' },
+                body: JSON.stringify({ query, variables }),
+            });
+            if (!res.ok)
+                throw new Error(`GitHub GraphQL failed: HTTP ${res.status}`);
+            const body = (await res.json());
+            if (body.errors?.length)
+                throw new Error(`GitHub GraphQL error: ${body.errors.map((e) => e.message).join('; ')}`);
+            return body.data;
+        },
+    };
+}
+//# sourceMappingURL=github-issues.js.map