@evref-bl/dev-nexus 0.1.0-alpha.0

package/dist/workTrackingGitLabProvider.d.ts

@@ -0,0 +1,62 @@
+import type { CreateWorkItemInput, GitLabWorkTrackingConfig, TrackerCapabilities, WorkComment, WorkItem, WorkItemPatch, WorkItemQuery, WorkItemRef, WorkStatus, WorkTrackerProvider } from "./workTrackingTypes.js";
+export declare const defaultGitLabApiBaseUrl = "https://gitlab.com/api/v4";
+export declare const gitLabStatusLabelPrefix = "status:";
+export interface GitLabWorkTrackerProviderOptions {
+    config: GitLabWorkTrackingConfig;
+    token?: string | null;
+    fetch?: typeof fetch;
+    apiBaseUrl?: string | null;
+    env?: Record<string, string | undefined>;
+    credentialRunner?: GitLabCredentialRunner | false;
+    credentialInteractive?: boolean;
+}
+export interface GitLabCredentialCommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+}
+export interface GitLabCredentialRequest {
+    protocol: "https";
+    host: string;
+    path?: string;
+}
+export type GitLabCredentialRunner = (request: GitLabCredentialRequest, options: {
+    interactive: boolean;
+}) => GitLabCredentialCommandResult;
+export declare class GitLabWorkTrackerProviderError extends Error {
+    constructor(message: string);
+}
+export declare const gitLabWorkTrackerCapabilities: TrackerCapabilities;
+export declare function createGitLabWorkTrackerProvider(options: GitLabWorkTrackerProviderOptions): GitLabWorkTrackerProvider;
+export declare class GitLabWorkTrackerProvider implements WorkTrackerProvider {
+    readonly provider = "gitlab";
+    readonly capabilities: TrackerCapabilities;
+    private readonly config;
+    private readonly fetchFn;
+    private readonly apiBaseUrl;
+    private readonly staticPrivateToken?;
+    private readonly credentialRunner?;
+    private readonly credentialInteractive;
+    private credentialHeaders;
+    constructor(options: GitLabWorkTrackerProviderOptions);
+    createWorkItem(input: CreateWorkItemInput): Promise<WorkItem>;
+    listWorkItems(query?: WorkItemQuery): Promise<WorkItem[]>;
+    getWorkItem(ref: WorkItemRef): Promise<WorkItem>;
+    updateWorkItem(ref: WorkItemRef, patch: WorkItemPatch): Promise<WorkItem>;
+    addComment(ref: WorkItemRef, body: string): Promise<WorkComment>;
+    setStatus(ref: WorkItemRef, status: WorkStatus): Promise<WorkItem>;
+    private getIssue;
+    private issuePath;
+    private requestJson;
+    private issueToWorkItem;
+    private noteToWorkComment;
+    private issueExternalRef;
+    private authorizationHeaders;
+}
+export declare function normalizeGitLabApiBaseUrl(hostOrApiBaseUrl?: string | null): string;
+export declare function gitLabCredentialRequest(config: Pick<GitLabWorkTrackingConfig, "host" | "repository">): GitLabCredentialRequest;
+export declare function normalizeGitLabCredentialHost(hostOrApiBaseUrl?: string | null): string;
+export declare function defaultGitLabCredentialRunner(request: GitLabCredentialRequest, options: {
+    interactive: boolean;
+}): GitLabCredentialCommandResult;

package/dist/workTrackingGitLabProvider.js

@@ -0,0 +1,523 @@
+import { spawnSync } from "node:child_process";
+export const defaultGitLabApiBaseUrl = "https://gitlab.com/api/v4";
+export const gitLabStatusLabelPrefix = "status:";
+const openStatuses = new Set([
+    "todo",
+    "ready",
+    "in_progress",
+    "blocked",
+]);
+const closedStatuses = new Set(["done", "wont_do"]);
+const workStatuses = new Set([
+    ...openStatuses,
+    ...closedStatuses,
+]);
+export class GitLabWorkTrackerProviderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GitLabWorkTrackerProviderError";
+    }
+}
+export const gitLabWorkTrackerCapabilities = {
+    createItem: true,
+    listItems: true,
+    getItem: true,
+    updateItem: true,
+    comment: true,
+    labels: true,
+    assignees: true,
+    milestones: true,
+    board: false,
+    boardStatus: false,
+    draftItems: false,
+    webhooks: false,
+};
+export function createGitLabWorkTrackerProvider(options) {
+    return new GitLabWorkTrackerProvider(options);
+}
+export class GitLabWorkTrackerProvider {
+    provider = "gitlab";
+    capabilities = gitLabWorkTrackerCapabilities;
+    config;
+    fetchFn;
+    apiBaseUrl;
+    staticPrivateToken;
+    credentialRunner;
+    credentialInteractive;
+    credentialHeaders;
+    constructor(options) {
+        this.config = options.config;
+        this.fetchFn = options.fetch ?? fetch;
+        this.apiBaseUrl = normalizeGitLabApiBaseUrl(options.apiBaseUrl ?? options.config.host);
+        this.staticPrivateToken =
+            optionalNonEmptyString(options.token, "token") ??
+                optionalNonEmptyString((options.env ?? process.env).GITLAB_TOKEN, "GITLAB_TOKEN") ??
+                optionalNonEmptyString((options.env ?? process.env).GL_TOKEN, "GL_TOKEN");
+        this.credentialRunner =
+            options.credentialRunner === false
+                ? undefined
+                : options.credentialRunner ?? defaultGitLabCredentialRunner;
+        this.credentialInteractive = options.credentialInteractive ?? false;
+    }
+    async createWorkItem(input) {
+        const status = input.status ?? "todo";
+        assertWorkStatus(status);
+        const created = await this.requestJson("POST", this.issuePath(), {
+            title: requiredNonEmptyString(input.title, "title"),
+            ...(input.description !== undefined
+                ? { description: input.description }
+                : {}),
+            ...requestLabels(labelsWithStatus(input.labels, status)),
+            ...requestAssignees(input.assignees),
+            ...requestMilestone(input.milestone),
+        });
+        if (closedStatuses.has(status)) {
+            return this.updateWorkItem({ id: String(created.iid) }, { status });
+        }
+        return this.issueToWorkItem(created);
+    }
+    async listWorkItems(query = {}) {
+        const statuses = normalizeStatusFilter(query.status);
+        const state = gitLabStateForQuery(statuses);
+        const limit = normalizeLimit(query.limit);
+        const params = new URLSearchParams({
+            state,
+            per_page: String(limit ? Math.min(Math.max(limit, 1), 100) : 100),
+            page: "1",
+        });
+        const labels = normalizeStringArray(query.labels, "labels");
+        if (labels.length > 0) {
+            params.set("labels", labels.join(","));
+        }
+        const issues = await this.requestJson("GET", `${this.issuePath()}?${params.toString()}`);
+        const assignees = normalizeStringArray(query.assignees, "assignees");
+        const search = query.search?.trim().toLowerCase();
+        const items = issues
+            .map((issue) => this.issueToWorkItem(issue))
+            .filter((item) => matchesStatusFilter(item, statuses))
+            .filter((item) => matchesStringFilter(item.assignees, assignees))
+            .filter((item) => !search || matchesSearch(item, search));
+        return limit === undefined ? items : items.slice(0, limit);
+    }
+    async getWorkItem(ref) {
+        return this.issueToWorkItem(await this.getIssue(ref));
+    }
+    async updateWorkItem(ref, patch) {
+        const issueIid = issueIidFromRef(ref);
+        const body = {};
+        if (patch.title !== undefined) {
+            body.title = requiredNonEmptyString(patch.title, "title");
+        }
+        if (patch.description !== undefined) {
+            body.description = patch.description;
+        }
+        if (patch.assignees !== undefined) {
+            Object.assign(body, requestAssignees(patch.assignees));
+        }
+        if (patch.milestone !== undefined) {
+            Object.assign(body, requestMilestone(patch.milestone));
+        }
+        if (patch.status !== undefined) {
+            assertWorkStatus(patch.status);
+            body.state_event = closedStatuses.has(patch.status) ? "close" : "reopen";
+        }
+        if (patch.labels !== undefined || patch.status !== undefined) {
+            const baseLabels = patch.labels !== undefined
+                ? normalizeStringArray(patch.labels, "labels")
+                : labelNames(await this.getIssue(ref));
+            Object.assign(body, requestLabels(labelsWithStatus(baseLabels, patch.status)));
+        }
+        return this.issueToWorkItem(await this.requestJson("PUT", `${this.issuePath()}/${issueIid}`, body));
+    }
+    async addComment(ref, body) {
+        const issueIid = issueIidFromRef(ref);
+        const note = await this.requestJson("POST", `${this.issuePath()}/${issueIid}/notes`, {
+            body: requiredNonEmptyString(body, "body"),
+        });
+        return this.noteToWorkComment(note, issueIid);
+    }
+    async setStatus(ref, status) {
+        return this.updateWorkItem(ref, { status });
+    }
+    async getIssue(ref) {
+        const issueIid = issueIidFromRef(ref);
+        return this.requestJson("GET", `${this.issuePath()}/${issueIid}`);
+    }
+    issuePath() {
+        return `/projects/${encodePathSegment(this.config.repository.id)}/issues`;
+    }
+    async requestJson(method, pathAndQuery, body) {
+        const url = new URL(pathAndQuery.replace(/^\/+/, ""), `${this.apiBaseUrl}/`);
+        const authorizationHeaders = this.authorizationHeaders();
+        const headers = {
+            Accept: "application/json",
+            "User-Agent": "dev-nexus",
+            ...authorizationHeaders,
+        };
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        const response = await this.fetchFn(url, {
+            method,
+            headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        if (!response.ok) {
+            const message = await gitLabErrorMessage(response, method, url);
+            throw new GitLabWorkTrackerProviderError(gitLabErrorMessageWithCredentialHint(message, response, authorizationHeaders, this.config));
+        }
+        return (await response.json());
+    }
+    issueToWorkItem(issue) {
+        return {
+            id: `gitlab-${issue.iid}`,
+            title: requiredNonEmptyString(issue.title, "issue.title"),
+            description: issue.description ?? null,
+            status: workStatusFromIssue(issue),
+            provider: "gitlab",
+            labels: userLabelNames(issue),
+            assignees: assigneeUsernames(issue),
+            milestone: issue.milestone?.title ?? null,
+            createdAt: issue.created_at ?? null,
+            updatedAt: issue.updated_at ?? null,
+            closedAt: issue.closed_at ?? null,
+            webUrl: issue.web_url ?? null,
+            externalRef: this.issueExternalRef(issue),
+        };
+    }
+    noteToWorkComment(note, issueIid) {
+        return {
+            id: `gitlab-note-${note.id}`,
+            body: note.body ?? "",
+            author: note.author?.username ?? null,
+            createdAt: note.created_at ?? null,
+            updatedAt: note.updated_at ?? null,
+            externalRef: {
+                provider: "gitlab",
+                host: this.config.host ?? null,
+                repositoryId: this.config.repository.id,
+                itemId: String(note.id),
+                itemNumber: note.noteable_iid ?? issueIid,
+            },
+        };
+    }
+    issueExternalRef(issue) {
+        return {
+            provider: "gitlab",
+            host: this.config.host ?? null,
+            repositoryId: this.config.repository.id,
+            itemId: String(issue.iid),
+            itemNumber: issue.iid,
+            itemKey: issue.references?.full ?? issue.references?.relative ?? null,
+            nodeId: String(issue.id),
+            webUrl: issue.web_url ?? null,
+        };
+    }
+    authorizationHeaders() {
+        if (this.staticPrivateToken) {
+            return { "PRIVATE-TOKEN": this.staticPrivateToken };
+        }
+        if (this.credentialHeaders !== undefined) {
+            return this.credentialHeaders ?? {};
+        }
+        if (!this.credentialRunner) {
+            this.credentialHeaders = null;
+            return {};
+        }
+        const credential = fillGitLabCredential(this.credentialRunner, gitLabCredentialRequest(this.config), { interactive: this.credentialInteractive });
+        this.credentialHeaders = credential
+            ? authorizationHeadersFromCredential(credential)
+            : null;
+        return this.credentialHeaders ?? {};
+    }
+}
+export function normalizeGitLabApiBaseUrl(hostOrApiBaseUrl) {
+    const value = hostOrApiBaseUrl?.trim();
+    if (!value || value === "gitlab.com" || value === "https://gitlab.com") {
+        return defaultGitLabApiBaseUrl;
+    }
+    const url = value.startsWith("http://") || value.startsWith("https://")
+        ? new URL(value)
+        : new URL(`https://${value}`);
+    const normalizedPath = url.pathname.replace(/\/+$/, "");
+    if (normalizedPath.endsWith("/api/v4")) {
+        return `${url.protocol}//${url.host}${normalizedPath}`;
+    }
+    return `${url.protocol}//${url.host}${normalizedPath}/api/v4`;
+}
+export function gitLabCredentialRequest(config) {
+    return {
+        protocol: "https",
+        host: normalizeGitLabCredentialHost(config.host),
+        path: `${config.repository.id}.git`,
+    };
+}
+export function normalizeGitLabCredentialHost(hostOrApiBaseUrl) {
+    const value = hostOrApiBaseUrl?.trim();
+    if (!value || value === "gitlab.com" || value === "https://gitlab.com") {
+        return "gitlab.com";
+    }
+    const url = value.startsWith("http://") || value.startsWith("https://")
+        ? new URL(value)
+        : new URL(`https://${value}`);
+    return url.host;
+}
+export function defaultGitLabCredentialRunner(request, options) {
+    const result = spawnSync("git", ["credential", "fill"], {
+        input: gitLabCredentialInput(request),
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            ...(options.interactive
+                ? {}
+                : {
+                    GCM_INTERACTIVE: "0",
+                    GIT_TERMINAL_PROMPT: "0",
+                }),
+        },
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        ...(result.error ? { error: result.error } : {}),
+    };
+}
+function fillGitLabCredential(runner, request, options) {
+    const result = runner(request, options);
+    if (result.status !== 0 || result.error) {
+        return undefined;
+    }
+    const credential = parseGitLabCredentialOutput(result.stdout);
+    return credential.password || (credential.authtype && credential.credential)
+        ? credential
+        : undefined;
+}
+function authorizationHeadersFromCredential(credential) {
+    const authtype = optionalNonEmptyString(credential.authtype, "authtype");
+    const encodedCredential = optionalNonEmptyString(credential.credential, "credential");
+    if (authtype && encodedCredential) {
+        return { Authorization: `${authtype} ${encodedCredential}` };
+    }
+    const password = optionalNonEmptyString(credential.password, "password");
+    return password ? { "PRIVATE-TOKEN": password } : {};
+}
+function gitLabCredentialInput(request) {
+    return [
+        `protocol=${request.protocol}`,
+        `host=${request.host}`,
+        ...(request.path ? [`path=${request.path}`] : []),
+        "",
+    ].join("\n");
+}
+function parseGitLabCredentialOutput(output) {
+    const credential = {};
+    for (const line of output.split(/\r?\n/)) {
+        if (line.length === 0) {
+            continue;
+        }
+        const separator = line.indexOf("=");
+        if (separator <= 0) {
+            continue;
+        }
+        credential[line.slice(0, separator)] = line.slice(separator + 1);
+    }
+    return credential;
+}
+function workStatusFromIssue(issue) {
+    const statusLabel = labelNames(issue).find((label) => label.startsWith(gitLabStatusLabelPrefix));
+    if (statusLabel) {
+        const candidate = statusLabel.slice(gitLabStatusLabelPrefix.length);
+        if (workStatuses.has(candidate)) {
+            return candidate;
+        }
+    }
+    return issue.state === "closed" ? "done" : "todo";
+}
+function gitLabStateForQuery(statuses) {
+    if (!statuses || statuses.size === 0) {
+        return "all";
+    }
+    let hasOpen = false;
+    let hasClosed = false;
+    for (const status of statuses) {
+        hasOpen ||= openStatuses.has(status);
+        hasClosed ||= closedStatuses.has(status);
+    }
+    return hasOpen && hasClosed ? "all" : hasClosed ? "closed" : "opened";
+}
+function labelsWithStatus(labels, status) {
+    const normalized = normalizeStringArray(labels, "labels").filter((label) => !label.startsWith(gitLabStatusLabelPrefix));
+    if (status &&
+        ((openStatuses.has(status) && status !== "todo") || status === "wont_do")) {
+        normalized.push(`${gitLabStatusLabelPrefix}${status}`);
+    }
+    return dedupeStrings(normalized);
+}
+function userLabelNames(issue) {
+    return labelNames(issue).filter((label) => !label.startsWith(gitLabStatusLabelPrefix));
+}
+function labelNames(issue) {
+    return (issue.labels ?? [])
+        .filter((label) => Boolean(label && label.trim()))
+        .map((label) => label.trim());
+}
+function assigneeUsernames(issue) {
+    return (issue.assignees ?? [])
+        .map((assignee) => assignee.username ?? String(assignee.id ?? ""))
+        .filter((login) => Boolean(login && login.trim()))
+        .map((login) => login.trim());
+}
+function issueIidFromRef(ref) {
+    if (ref.provider && ref.provider !== "gitlab") {
+        throw new GitLabWorkTrackerProviderError(`gitlab provider cannot resolve ${ref.provider} work item refs`);
+    }
+    if (ref.externalRef?.provider && ref.externalRef.provider !== "gitlab") {
+        throw new GitLabWorkTrackerProviderError(`gitlab provider cannot resolve ${ref.externalRef.provider} external refs`);
+    }
+    const candidate = ref.externalRef?.itemNumber ??
+        ref.id ??
+        ref.externalRef?.itemId;
+    if (candidate === undefined || candidate === null) {
+        throw new GitLabWorkTrackerProviderError("GitLab issue IID is required");
+    }
+    if (typeof candidate === "number") {
+        return positiveInteger(candidate, "issue IID");
+    }
+    const normalized = candidate.trim().replace(/^gitlab-/, "");
+    return positiveInteger(Number(normalized), "issue IID");
+}
+function normalizeStatusFilter(status) {
+    if (status === undefined) {
+        return undefined;
+    }
+    const values = Array.isArray(status) ? status : [status];
+    const normalized = new Set();
+    for (const value of values) {
+        assertWorkStatus(value);
+        normalized.add(value);
+    }
+    return normalized;
+}
+function matchesStatusFilter(item, statuses) {
+    return !statuses || statuses.size === 0 || statuses.has(item.status);
+}
+function matchesStringFilter(itemValues, requiredValues) {
+    return requiredValues.every((value) => itemValues?.includes(value));
+}
+function matchesSearch(item, search) {
+    return [item.id, item.title, item.description ?? ""].some((value) => value.toLowerCase().includes(search));
+}
+function requestLabels(labels) {
+    return labels.length > 0 ? { labels: labels.join(",") } : {};
+}
+function requestAssignees(assignees) {
+    const assigneeIds = normalizePositiveIntegerArray(assignees, "assignees");
+    return assigneeIds.length > 0 ? { assignee_ids: assigneeIds } : {};
+}
+function requestMilestone(value) {
+    if (value === undefined) {
+        return {};
+    }
+    if (value === null) {
+        return { milestone_id: null };
+    }
+    return { milestone_id: positiveInteger(Number(value), "milestone") };
+}
+function normalizeLimit(limit) {
+    if (limit === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(limit) || limit < 0) {
+        throw new GitLabWorkTrackerProviderError("limit must be a non-negative integer");
+    }
+    return limit;
+}
+function normalizeStringArray(values, pathName) {
+    if (values === undefined) {
+        return [];
+    }
+    if (!Array.isArray(values)) {
+        throw new GitLabWorkTrackerProviderError(`${pathName} must be an array`);
+    }
+    return dedupeStrings(values.map((value, index) => requiredNonEmptyString(value, `${pathName}[${index}]`)));
+}
+function normalizePositiveIntegerArray(values, pathName) {
+    return normalizeStringArray(values, pathName).map((value, index) => positiveInteger(Number(value), `${pathName}[${index}]`));
+}
+function dedupeStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function assertWorkStatus(status) {
+    if (!workStatuses.has(status)) {
+        throw new GitLabWorkTrackerProviderError(`Invalid work status: ${status}`);
+    }
+}
+function positiveInteger(value, pathName) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new GitLabWorkTrackerProviderError(`${pathName} must be a positive integer`);
+    }
+    return value;
+}
+function requiredNonEmptyString(value, pathName) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new GitLabWorkTrackerProviderError(`${pathName} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalNonEmptyString(value, pathName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (value.trim().length === 0) {
+        return undefined;
+    }
+    return requiredNonEmptyString(value, pathName);
+}
+function encodePathSegment(value) {
+    return encodeURIComponent(requiredNonEmptyString(value, "path segment"));
+}
+async function gitLabErrorMessage(response, method, url) {
+    let detail;
+    try {
+        const body = (await response.json());
+        detail = gitLabErrorDetail(body);
+    }
+    catch {
+        detail = await response.text().catch(() => undefined);
+    }
+    return [
+        `GitLab request failed: ${method} ${url.pathname} returned ${response.status}`,
+        detail ? `: ${detail}` : "",
+    ].join("");
+}
+function gitLabErrorDetail(body) {
+    if (typeof body.error === "string") {
+        return body.error;
+    }
+    if (typeof body.message === "string") {
+        return body.message;
+    }
+    if (body.message && typeof body.message === "object") {
+        return JSON.stringify(body.message);
+    }
+    return undefined;
+}
+function gitLabErrorMessageWithCredentialHint(message, response, authorizationHeaders, config) {
+    if (authorizationHeaders.Authorization ||
+        authorizationHeaders["PRIVATE-TOKEN"] ||
+        (response.status !== 401 && response.status !== 403)) {
+        return message;
+    }
+    return (`${message}. No GitLab token or git credential was available for ` +
+        `${normalizeGitLabCredentialHost(config.host)}. Configure GITLAB_TOKEN, ` +
+        "GL_TOKEN, or a git credential helper.");
+}

package/dist/workTrackingJiraProvider.d.ts

@@ -0,0 +1,67 @@
+import type { CreateWorkItemInput, JiraWorkTrackingConfig, TrackerCapabilities, WorkComment, WorkItem, WorkItemPatch, WorkItemQuery, WorkItemRef, WorkStatus, WorkTrackerProvider } from "./workTrackingTypes.js";
+export declare const jiraStatusLabelPrefix = "status:";
+export declare const jiraRestApiPath = "/rest/api/3";
+export interface JiraWorkTrackerProviderOptions {
+    config: JiraWorkTrackingConfig;
+    email?: string | null;
+    apiToken?: string | null;
+    token?: string | null;
+    fetch?: typeof fetch;
+    apiBaseUrl?: string | null;
+    env?: Record<string, string | undefined>;
+    credentialRunner?: JiraCredentialRunner | false;
+    credentialInteractive?: boolean;
+}
+export interface JiraCredentialCommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+}
+export interface JiraCredentialRequest {
+    protocol: "https";
+    host: string;
+}
+export type JiraCredentialRunner = (request: JiraCredentialRequest, options: {
+    interactive: boolean;
+}) => JiraCredentialCommandResult;
+export declare class JiraWorkTrackerProviderError extends Error {
+    constructor(message: string);
+}
+export declare const jiraWorkTrackerCapabilities: TrackerCapabilities;
+export declare function jiraWorkTrackerCapabilitiesForConfig(config: Pick<JiraWorkTrackingConfig, "board">): TrackerCapabilities;
+export declare function createJiraWorkTrackerProvider(options: JiraWorkTrackerProviderOptions): JiraWorkTrackerProvider;
+export declare class JiraWorkTrackerProvider implements WorkTrackerProvider {
+    readonly provider = "jira";
+    readonly capabilities: TrackerCapabilities;
+    private readonly config;
+    private readonly fetchFn;
+    private readonly apiBaseUrl;
+    private readonly webBaseUrl;
+    private readonly staticAuthorizationHeader?;
+    private readonly credentialRunner?;
+    private readonly credentialInteractive;
+    private credentialAuthorizationHeader;
+    constructor(options: JiraWorkTrackerProviderOptions);
+    createWorkItem(input: CreateWorkItemInput): Promise<WorkItem>;
+    listWorkItems(query?: WorkItemQuery): Promise<WorkItem[]>;
+    getWorkItem(ref: WorkItemRef): Promise<WorkItem>;
+    updateWorkItem(ref: WorkItemRef, patch: WorkItemPatch): Promise<WorkItem>;
+    addComment(ref: WorkItemRef, body: string): Promise<WorkComment>;
+    setStatus(ref: WorkItemRef, status: WorkStatus): Promise<WorkItem>;
+    private getIssue;
+    private applyConfiguredTransition;
+    private requestJson;
+    private issueToWorkItem;
+    private commentToWorkComment;
+    private issueExternalRef;
+    private issueWebUrl;
+    private authorizationHeader;
+}
+export declare function normalizeJiraApiBaseUrl(hostOrApiBaseUrl?: string | null): string;
+export declare function normalizeJiraWebBaseUrl(hostOrApiBaseUrl?: string | null): string;
+export declare function jiraCredentialRequest(config: Pick<JiraWorkTrackingConfig, "host">): JiraCredentialRequest;
+export declare function normalizeJiraCredentialHost(hostOrApiBaseUrl?: string | null): string;
+export declare function defaultJiraCredentialRunner(request: JiraCredentialRequest, options: {
+    interactive: boolean;
+}): JiraCredentialCommandResult;