jirallm 0.1.1 → 0.3.0

package/dist/lib/jiraClient.js

@@ -1,7 +1,72 @@
 import { createWriteStream } from 'fs';
-import { mkdir } from 'fs/promises';
-import { dirname } from 'path';
+import { mkdir, readFile, stat } from 'fs/promises';
+import { basename, dirname } from 'path';
 import { pipeline } from 'stream/promises';
+import { markdownToWiki } from './markdownToWiki.js';
+function extractActiveSprintName(raw) {
+    if (!raw)
+        return undefined;
+    const arr = Array.isArray(raw) ? raw : [raw];
+    const items = arr
+        .map((entry) => {
+        if (entry && typeof entry === 'object')
+            return entry;
+        if (typeof entry === 'string') {
+            const nameMatch = entry.match(/name=([^,\]]+)/);
+            const stateMatch = entry.match(/state=([^,\]]+)/);
+            return {
+                name: nameMatch?.[1],
+                state: stateMatch?.[1],
+            };
+        }
+        return undefined;
+    })
+        .filter((x) => Boolean(x));
+    const active = items.find((s) => s.state?.toLowerCase() === 'active');
+    return (active ?? items[items.length - 1])?.name;
+}
+function extractCustomFieldValue(raw, type) {
+    if (raw === null || raw === undefined)
+        return undefined;
+    switch (type) {
+        case 'scalar':
+            return typeof raw === 'string' || typeof raw === 'number' || typeof raw === 'boolean'
+                ? raw
+                : undefined;
+        case 'number':
+            return typeof raw === 'number' ? raw : undefined;
+        case 'select':
+            if (typeof raw === 'object' && raw !== null && 'value' in raw) {
+                return raw.value;
+            }
+            return undefined;
+        case 'user':
+            if (typeof raw === 'object' && raw !== null && 'displayName' in raw) {
+                return raw.displayName;
+            }
+            return undefined;
+        case 'sprint':
+            return extractActiveSprintName(raw);
+        case 'array':
+            if (!Array.isArray(raw))
+                return undefined;
+            return raw
+                .map((item) => {
+                if (typeof item === 'string')
+                    return item;
+                if (item && typeof item === 'object' && 'value' in item) {
+                    return item.value;
+                }
+                if (item && typeof item === 'object' && 'name' in item) {
+                    return item.name;
+                }
+                return undefined;
+            })
+                .filter((x) => x !== undefined);
+        default:
+            return undefined;
+    }
+}
 const COMMON_EPIC_FIELDS = [
     'customfield_10014',
     'customfield_10008',
@@ -11,10 +76,50 @@ const COMMON_EPIC_FIELDS = [
 export class JiraClient {
     config;
     authHeader;
+    fieldsCache;
+    sprintFieldIdCache;
+    storyPointsFieldIdCache;
     constructor(config, apiToken) {
         this.config = config;
         this.authHeader = `Basic ${Buffer.from(`${config.userEmail}:${apiToken}`).toString('base64')}`;
     }
+    async listFields() {
+        if (this.fieldsCache)
+            return this.fieldsCache;
+        const all = await this.makeRequest('/field');
+        this.fieldsCache = all;
+        return all;
+    }
+    async detectSprintFieldId() {
+        if (this.sprintFieldIdCache !== undefined)
+            return this.sprintFieldIdCache ?? undefined;
+        try {
+            const fields = await this.listFields();
+            const match = fields.find((f) => f.schema?.custom === 'com.pyxis.greenhopper.jira:gh-sprint' ||
+                f.name?.toLowerCase() === 'sprint');
+            this.sprintFieldIdCache = match?.id ?? null;
+            return match?.id;
+        }
+        catch {
+            this.sprintFieldIdCache = null;
+            return undefined;
+        }
+    }
+    async detectStoryPointsFieldId() {
+        if (this.storyPointsFieldIdCache !== undefined)
+            return this.storyPointsFieldIdCache ?? undefined;
+        try {
+            const fields = await this.listFields();
+            const match = fields.find((f) => f.schema?.custom === 'com.atlassian.jira.plugin.system.customfieldtypes:float' &&
+                /story\s*points?/i.test(f.name ?? '')) ?? fields.find((f) => /^story\s*points?$/i.test(f.name ?? ''));
+            this.storyPointsFieldIdCache = match?.id ?? null;
+            return match?.id;
+        }
+        catch {
+            this.storyPointsFieldIdCache = null;
+            return undefined;
+        }
+    }
     extractEpicFromFields(fields) {
         for (const fieldId of COMMON_EPIC_FIELDS) {
             const epicField = fields[fieldId];
@@ -213,8 +318,8 @@ export class JiraClient {
     async getCurrentUser() {
         return this.makeRequest('/myself');
     }
-    async fetchIssueDetails(issueKey) {
-        const fields = [
+    async fetchIssueDetails(issueKey, options = {}) {
+        const baseFields = [
             'summary',
             'description',
             'status',
@@ -222,7 +327,16 @@ export class JiraClient {
             'attachment',
             'issuetype',
             ...COMMON_EPIC_FIELDS,
-        ].join(',');
+        ];
+        const sprintFieldId = options.customFieldDefs?.sprint?.id ?? (await this.detectSprintFieldId());
+        const storyPointsFieldId = options.customFieldDefs?.storyPoints?.id ?? (await this.detectStoryPointsFieldId());
+        const extraFields = options.jiraFieldIds ?? [];
+        const fieldSet = new Set([...baseFields, ...extraFields]);
+        if (sprintFieldId)
+            fieldSet.add(sprintFieldId);
+        if (storyPointsFieldId)
+            fieldSet.add(storyPointsFieldId);
+        const fields = [...fieldSet].join(',');
         const response = await this.makeRequest(`/issue/${issueKey}?fields=${fields}`);
         const comments = await this.fetchIssueComments(issueKey);
         const changelog = await this.fetchIssueChangelog(issueKey);
@@ -232,21 +346,29 @@ export class JiraClient {
             url: att.content,
         })) || [];
         const history = this.mergeHistory(comments, changelog, attachmentMetadata);
-        return {
+        return this.buildTaskData(response, attachmentMetadata, history, {
+            sprintFieldId,
+            storyPointsFieldId,
+            customFieldDefs: options.customFieldDefs ?? {},
+        });
+    }
+    buildTaskData(response, attachmentMetadata, history, ctx) {
+        const f = response.fields;
+        const data = {
             key: response.key,
-            title: response.fields.summary,
-            status: response.fields.status?.name || 'Unknown',
-            description: this.convertADFToMarkdown(response.fields.description, attachmentMetadata),
-            issueType: response.fields.issuetype?.name,
-            parent: response.fields.parent
+            title: f.summary,
+            status: f.status?.name || 'Unknown',
+            description: this.convertADFToMarkdown(f.description, attachmentMetadata),
+            issueType: f.issuetype?.name,
+            parent: f.parent
                 ? {
-                    key: response.fields.parent.key,
-                    title: response.fields.parent.fields.summary,
-                    status: response.fields.parent.fields.status?.name,
+                    key: f.parent.key,
+                    title: f.parent.fields.summary,
+                    status: f.parent.fields.status?.name,
                 }
                 : undefined,
-            epic: this.extractEpicFromFields(response.fields),
-            attachments: response.fields.attachment?.map((att) => ({
+            epic: this.extractEpicFromFields(f),
+            attachments: f.attachment?.map((att) => ({
                 id: att.id,
                 filename: att.filename,
                 url: att.content,
@@ -254,6 +376,100 @@ export class JiraClient {
             })) || [],
             history,
         };
+        const priority = f.priority;
+        if (priority?.name)
+            data.priority = priority.name;
+        const resolution = f.resolution;
+        if (resolution?.name)
+            data.resolution = resolution.name;
+        const assignee = f.assignee;
+        if (assignee?.displayName)
+            data.assignee = assignee.displayName;
+        const reporter = f.reporter;
+        if (reporter?.displayName)
+            data.reporter = reporter.displayName;
+        const creator = f.creator;
+        if (creator?.displayName)
+            data.creator = creator.displayName;
+        if (typeof f.created === 'string')
+            data.createdAt = f.created;
+        if (typeof f.updated === 'string')
+            data.updatedAt = f.updated;
+        if (typeof f.duedate === 'string' && f.duedate)
+            data.dueDate = f.duedate;
+        if (typeof f.resolutiondate === 'string' && f.resolutiondate) {
+            data.resolutionDate = f.resolutiondate;
+        }
+        const components = f.components;
+        if (components?.length)
+            data.components = components.map((c) => c.name);
+        const labels = f.labels;
+        if (labels?.length)
+            data.labels = labels;
+        const fixVersions = f.fixVersions;
+        if (fixVersions?.length)
+            data.fixVersions = fixVersions.map((v) => v.name);
+        const versions = f.versions;
+        if (versions?.length)
+            data.versions = versions.map((v) => v.name);
+        if (ctx.sprintFieldId) {
+            const sprintField = f[ctx.sprintFieldId];
+            const sprintName = extractActiveSprintName(sprintField);
+            if (sprintName)
+                data.sprint = sprintName;
+        }
+        if (ctx.storyPointsFieldId) {
+            const sp = f[ctx.storyPointsFieldId];
+            if (typeof sp === 'number')
+                data.storyPoints = sp;
+        }
+        const tt = f.timetracking;
+        if (tt && (tt.originalEstimate || tt.remainingEstimate || tt.timeSpent)) {
+            data.timetracking = {
+                originalEstimate: tt.originalEstimate,
+                remainingEstimate: tt.remainingEstimate,
+                timeSpent: tt.timeSpent,
+            };
+        }
+        const issueLinks = f.issuelinks;
+        if (issueLinks?.length) {
+            const mapped = [];
+            for (const link of issueLinks) {
+                if (link.inwardIssue) {
+                    mapped.push({
+                        type: link.type.inward ?? link.type.name ?? 'relates to',
+                        key: link.inwardIssue.key,
+                        title: link.inwardIssue.fields.summary,
+                        status: link.inwardIssue.fields.status?.name,
+                    });
+                }
+                else if (link.outwardIssue) {
+                    mapped.push({
+                        type: link.type.outward ?? link.type.name ?? 'relates to',
+                        key: link.outwardIssue.key,
+                        title: link.outwardIssue.fields.summary,
+                        status: link.outwardIssue.fields.status?.name,
+                    });
+                }
+            }
+            if (mapped.length)
+                data.issueLinks = mapped;
+        }
+        const customFieldDefs = ctx.customFieldDefs;
+        if (Object.keys(customFieldDefs).length > 0) {
+            const cf = {};
+            for (const [friendly, def] of Object.entries(customFieldDefs)) {
+                if (friendly === 'sprint' || friendly === 'storyPoints')
+                    continue;
+                const raw = f[def.id];
+                const value = extractCustomFieldValue(raw, def.type);
+                if (value !== undefined && value !== null && value !== '')
+                    cf[friendly] = value;
+            }
+            if (Object.keys(cf).length > 0)
+                data.customFields = cf;
+        }
+        return data;
     }
     async fetchIssueComments(issueKey) {
         const allComments = [];
@@ -291,6 +507,430 @@ export class JiraClient {
             return [];
         }
     }
+    async addComment(issueKey, wikiBody, parentCommentId) {
+        const url = `${this.config.baseUrl}/rest/api/2/issue/${issueKey}/comment`;
+        const payload = { body: wikiBody };
+        if (parentCommentId)
+            payload.parentId = parentCommentId;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Jira addComment failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        const json = (await response.json());
+        return { id: json.id };
+    }
+    async addWorklog(issueKey, payload) {
+        const url = `${this.config.baseUrl}/rest/api/2/issue/${issueKey}/worklog`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Jira addWorklog failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        const json = (await response.json());
+        return { id: json.id, issueId: json.issueId };
+    }
+    async deleteComment(issueKey, commentId) {
+        const url = `${this.config.baseUrl}/rest/api/2/issue/${issueKey}/comment/${commentId}`;
+        const response = await fetch(url, {
+            method: 'DELETE',
+            headers: { Authorization: this.authHeader, Accept: 'application/json' },
+        });
+        if (!response.ok && response.status !== 204) {
+            const errorText = await response.text();
+            throw new Error(`Jira deleteComment failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+    }
+    async makeAgileRequest(endpoint, options = {}) {
+        const url = `${this.config.baseUrl}/rest/agile/1.0${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Jira Agile API request failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        return response.json();
+    }
+    async findBoardByName(name) {
+        const response = await this.makeAgileRequest(`/board?name=${encodeURIComponent(name)}`);
+        const exact = response.values.find((b) => b.name === name);
+        if (exact)
+            return exact;
+        if (response.values.length === 1)
+            return response.values[0];
+        if (response.values.length === 0) {
+            throw new Error(`No board found matching "${name}".`);
+        }
+        throw new Error(`Multiple boards matched "${name}": ${response.values.map((b) => b.name).join(', ')}. Use the exact name.`);
+    }
+    async getBoardConfiguration(boardId) {
+        return this.makeAgileRequest(`/board/${boardId}/configuration`);
+    }
+    async getBoardColumnStatusIds(boardName, columnName) {
+        const board = await this.findBoardByName(boardName);
+        const config = await this.getBoardConfiguration(board.id);
+        const column = config.columnConfig.columns.find((c) => c.name === columnName);
+        if (!column) {
+            const available = config.columnConfig.columns.map((c) => c.name).join(', ');
+            throw new Error(`Column "${columnName}" not found on board "${boardName}". Available: ${available}`);
+        }
+        return column.statuses.map((s) => s.id);
+    }
+    async searchByJql(jql, fields = ['summary', 'status', 'assignee', 'issuetype']) {
+        const all = [];
+        let nextPageToken;
+        do {
+            const body = { jql, fields, maxResults: 100 };
+            if (nextPageToken)
+                body.nextPageToken = nextPageToken;
+            const response = await this.makeRequest('/search/jql', { method: 'POST', body: JSON.stringify(body) });
+            all.push(...response.issues);
+            nextPageToken = response.isLast === false ? response.nextPageToken : undefined;
+        } while (nextPageToken);
+        return all;
+    }
+    async searchIssues(jql, opts = {}) {
+        const body = {
+            jql,
+            fields: opts.fields ?? ['summary', 'status', 'assignee', 'issuetype'],
+            maxResults: opts.limit ?? 50,
+        };
+        if (opts.nextPageToken)
+            body.nextPageToken = opts.nextPageToken;
+        const response = await this.makeRequest('/search/jql', { method: 'POST', body: JSON.stringify(body) });
+        return {
+            issues: response.issues,
+            nextPageToken: response.nextPageToken,
+            isLast: response.isLast !== false,
+        };
+    }
+    async listProjects(opts = {}) {
+        const params = new URLSearchParams();
+        if (opts.query)
+            params.set('query', opts.query);
+        if (opts.startAt !== undefined)
+            params.set('startAt', String(opts.startAt));
+        if (opts.limit !== undefined)
+            params.set('maxResults', String(opts.limit));
+        const qs = params.toString();
+        return this.makeRequest(`/project/search${qs ? `?${qs}` : ''}`);
+    }
+    async listBoards(opts = {}) {
+        const params = new URLSearchParams();
+        if (opts.projectKey)
+            params.set('projectKeyOrId', opts.projectKey);
+        if (opts.type)
+            params.set('type', opts.type);
+        if (opts.name)
+            params.set('name', opts.name);
+        if (opts.startAt !== undefined)
+            params.set('startAt', String(opts.startAt));
+        if (opts.limit !== undefined)
+            params.set('maxResults', String(opts.limit));
+        const qs = params.toString();
+        return this.makeAgileRequest(`/board${qs ? `?${qs}` : ''}`);
+    }
+    async listSprints(boardId, opts = {}) {
+        const params = new URLSearchParams();
+        if (opts.state)
+            params.set('state', opts.state);
+        if (opts.startAt !== undefined)
+            params.set('startAt', String(opts.startAt));
+        if (opts.limit !== undefined)
+            params.set('maxResults', String(opts.limit));
+        const qs = params.toString();
+        return this.makeAgileRequest(`/board/${boardId}/sprint${qs ? `?${qs}` : ''}`);
+    }
+    async listIssueTypes(projectKey) {
+        if (!projectKey)
+            return this.makeRequest('/issuetype');
+        const project = await this.makeRequest(`/project/${projectKey}`);
+        return this.makeRequest(`/issuetype/project?projectId=${project.id}`);
+    }
+    async listComponents(projectKey) {
+        return this.makeRequest(`/project/${projectKey}/components`);
+    }
+    /**
+     * Fetch the fields available on the create screen for a given issue type, including
+     * allowedValues for select fields — helps users discover valid custom-field option strings.
+     */
+    async getCreateFields(projectKey, issueTypeName) {
+        const types = await this.listIssueTypes(projectKey);
+        const match = types.find((t) => t.name.toLowerCase() === issueTypeName.toLowerCase());
+        if (!match) {
+            throw new Error(`Issue type "${issueTypeName}" not found in project ${projectKey}. ` +
+                `Available: ${types.map((t) => t.name).join(', ')}.`);
+        }
+        const response = await this.makeRequest(`/issue/createmeta/${projectKey}/issuetypes/${match.id}`);
+        return response.fields.map((f) => ({
+            fieldId: f.fieldId,
+            name: f.name,
+            required: f.required,
+            schemaType: f.schema?.type,
+            allowedValues: f.allowedValues
+                ?.map((v) => v.value ?? v.name)
+                .filter((v) => Boolean(v)),
+        }));
+    }
+    async listLinkTypes() {
+        const response = await this.makeRequest('/issueLinkType');
+        return response.issueLinkTypes;
+    }
+    async listPriorities() {
+        return this.makeRequest('/priority');
+    }
+    async listStatuses(projectKey) {
+        if (!projectKey)
+            return this.makeRequest('/status');
+        const statuses = await this.makeRequest(`/project/${projectKey}/statuses`);
+        const seen = new Map();
+        for (const entry of statuses) {
+            for (const s of entry.statuses)
+                seen.set(s.id, s);
+        }
+        return [...seen.values()];
+    }
+    async getIssueTransitions(issueKey) {
+        const response = await this.makeRequest(`/issue/${issueKey}/transitions`);
+        return response.transitions;
+    }
+    async transitionIssue(issueKey, targetStatus) {
+        const transitions = await this.getIssueTransitions(issueKey);
+        const match = transitions.find((t) => t.to.name === targetStatus) ??
+            transitions.find((t) => t.name === targetStatus);
+        if (!match) {
+            const available = transitions.map((t) => `"${t.name}" → "${t.to.name}"`).join(', ');
+            throw new Error(`No transition to "${targetStatus}" available on ${issueKey}. Available: ${available}`);
+        }
+        const url = `${this.config.baseUrl}/rest/api/3/issue/${issueKey}/transitions`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ transition: { id: match.id } }),
+        });
+        if (!response.ok && response.status !== 204) {
+            const errorText = await response.text();
+            throw new Error(`Jira transition failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        return { name: match.name, id: match.id };
+    }
+    async createIssue(input) {
+        const fields = {
+            project: { key: input.projectKey },
+            issuetype: { name: input.issueType },
+            summary: input.summary,
+        };
+        if (input.descriptionMarkdown !== undefined) {
+            fields.description = markdownToWiki(input.descriptionMarkdown);
+        }
+        if (input.assigneeAccountId)
+            fields.assignee = { accountId: input.assigneeAccountId };
+        if (input.labels)
+            fields.labels = input.labels;
+        if (input.priority)
+            fields.priority = { name: input.priority };
+        if (input.parentKey)
+            fields.parent = { key: input.parentKey };
+        if (input.components)
+            fields.components = input.components.map((name) => ({ name }));
+        if (input.customFields)
+            Object.assign(fields, input.customFields);
+        const url = `${this.config.baseUrl}/rest/api/2/issue`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ fields }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Jira createIssue failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        return response.json();
+    }
+    async editIssue(issueKey, input) {
+        const fields = {};
+        if (input.summary !== undefined)
+            fields.summary = input.summary;
+        if (input.descriptionMarkdown !== undefined) {
+            fields.description = markdownToWiki(input.descriptionMarkdown);
+        }
+        if (input.assigneeAccountId !== undefined) {
+            fields.assignee = input.assigneeAccountId === null
+                ? null
+                : { accountId: input.assigneeAccountId };
+        }
+        if (input.labels !== undefined)
+            fields.labels = input.labels;
+        if (input.priority !== undefined)
+            fields.priority = { name: input.priority };
+        if (input.components !== undefined)
+            fields.components = input.components.map((name) => ({ name }));
+        if (input.customFields !== undefined)
+            Object.assign(fields, input.customFields);
+        if (Object.keys(fields).length === 0) {
+            throw new Error('editIssue called with no fields to update.');
+        }
+        const url = `${this.config.baseUrl}/rest/api/2/issue/${issueKey}`;
+        const response = await fetch(url, {
+            method: 'PUT',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ fields }),
+        });
+        if (!response.ok && response.status !== 204) {
+            const errorText = await response.text();
+            throw new Error(`Jira editIssue failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+    }
+    async assignIssue(issueKey, accountIdOrNull) {
+        const url = `${this.config.baseUrl}/rest/api/3/issue/${issueKey}/assignee`;
+        const response = await fetch(url, {
+            method: 'PUT',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ accountId: accountIdOrNull }),
+        });
+        if (!response.ok && response.status !== 204) {
+            const errorText = await response.text();
+            throw new Error(`Jira assignIssue failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+    }
+    async linkIssues(inwardKey, outwardKey, linkTypeName, comment) {
+        const payload = {
+            type: { name: linkTypeName },
+            inwardIssue: { key: inwardKey },
+            outwardIssue: { key: outwardKey },
+        };
+        if (comment)
+            payload.comment = { body: markdownToWiki(comment) };
+        const url = `${this.config.baseUrl}/rest/api/3/issueLink`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok && response.status !== 201) {
+            const errorText = await response.text();
+            throw new Error(`Jira linkIssues failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+    }
+    async removeIssueLink(linkId) {
+        const url = `${this.config.baseUrl}/rest/api/3/issueLink/${linkId}`;
+        const response = await fetch(url, {
+            method: 'DELETE',
+            headers: { Authorization: this.authHeader, Accept: 'application/json' },
+        });
+        if (!response.ok && response.status !== 204) {
+            const errorText = await response.text();
+            throw new Error(`Jira removeIssueLink failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+    }
+    async listWatchers(issueKey) {
+        const response = await this.makeRequest(`/issue/${issueKey}/watchers`);
+        return response.watchers;
+    }
+    async addWatcher(issueKey, accountId) {
+        const url = `${this.config.baseUrl}/rest/api/3/issue/${issueKey}/watchers`;
+        // Jira quirk: body is a JSON string (account id in quotes), not an object
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(accountId),
+        });
+        if (!response.ok && response.status !== 204) {
+            const errorText = await response.text();
+            throw new Error(`Jira addWatcher failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+    }
+    async removeWatcher(issueKey, accountId) {
+        const url = `${this.config.baseUrl}/rest/api/3/issue/${issueKey}/watchers?accountId=${encodeURIComponent(accountId)}`;
+        const response = await fetch(url, {
+            method: 'DELETE',
+            headers: { Authorization: this.authHeader, Accept: 'application/json' },
+        });
+        if (!response.ok && response.status !== 204) {
+            const errorText = await response.text();
+            throw new Error(`Jira removeWatcher failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+    }
+    async uploadAttachment(issueKey, filePath) {
+        await stat(filePath);
+        const buf = await readFile(filePath);
+        const form = new FormData();
+        const arr = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        form.append('file', new Blob([arr]), basename(filePath));
+        const url = `${this.config.baseUrl}/rest/api/3/issue/${issueKey}/attachments`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: this.authHeader,
+                Accept: 'application/json',
+                'X-Atlassian-Token': 'no-check',
+            },
+            body: form,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Jira uploadAttachment failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        return response.json();
+    }
+    async deleteAttachment(attachmentId) {
+        const url = `${this.config.baseUrl}/rest/api/3/attachment/${attachmentId}`;
+        const response = await fetch(url, {
+            method: 'DELETE',
+            headers: { Authorization: this.authHeader, Accept: 'application/json' },
+        });
+        if (!response.ok && response.status !== 204) {
+            const errorText = await response.text();
+            throw new Error(`Jira deleteAttachment failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+    }
     async downloadAttachment(attachmentUrl, outputPath) {
         await mkdir(dirname(outputPath), { recursive: true });
         const response = await fetch(attachmentUrl, {