@damian87/omp 0.1.0

package/dist/src/jira.d.ts

@@ -0,0 +1,149 @@
+export type JiraMode = 'live' | 'dry-run';
+export type JiraOperationName = 'create' | 'comment' | 'update' | 'transition' | 'link';
+export interface JiraOperationsConfig {
+    create?: boolean;
+    update?: boolean;
+    comment?: boolean;
+    transition?: boolean | 'discover';
+    link?: boolean | 'discover';
+}
+export interface JiraConfig {
+    tracker: 'jira';
+    mode: JiraMode;
+    baseUrl?: string;
+    /** Backcompat alias used by early scaffold tests. */
+    siteUrl?: string;
+    email?: string;
+    apiToken?: string;
+    projectKey?: string;
+    defaultIssueType: string;
+    operations: Required<JiraOperationsConfig>;
+    transitions: Record<string, string>;
+    linkType?: string;
+    labels?: string[];
+    components?: string[];
+    priority?: string;
+    source: string[];
+}
+export interface JiraTicketInput {
+    summary: string;
+    description: string;
+    issueType?: string;
+    labels?: string[];
+    components?: string[];
+    priority?: string;
+    acceptanceCriteria?: string[];
+    implementationNotes?: string[];
+}
+export interface JiraRenderedIssue {
+    operation: 'create';
+    endpoint: string;
+    payload: {
+        fields: Record<string, unknown>;
+    };
+}
+export interface JiraFallback {
+    operation: JiraOperationName;
+    reason: string;
+    target: string;
+    payload: unknown;
+    humanAction: string;
+}
+export interface JiraApplyOptions {
+    operation: JiraOperationName;
+    target?: string;
+    ticket?: JiraTicketInput;
+    comment?: string;
+    update?: Partial<JiraTicketInput>;
+    transitionState?: string;
+    linkTarget?: string;
+    dryRun?: boolean;
+}
+export interface JiraResult {
+    ok: boolean;
+    live: boolean;
+    operation: JiraOperationName;
+    response?: unknown;
+    fallback?: JiraFallback;
+}
+export declare function loadDotEnv(cwd?: string): Record<string, string>;
+export declare function discoverJiraConfig(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    overrides?: Partial<JiraConfig>;
+    configPath?: string;
+} | string, envArg?: NodeJS.ProcessEnv): JiraConfig;
+export declare function ticketFromMarkdown(markdown: string, fallbackSummary?: string): JiraTicketInput;
+export declare function readTicketInput(path: string): JiraTicketInput;
+export declare function renderCreateIssue(ticket: JiraTicketInput, config?: JiraConfig): JiraRenderedIssue;
+export declare function renderComment(comment: string): {
+    body: string;
+};
+export declare function renderSafeUpdate(update: Partial<JiraTicketInput>, config?: JiraConfig): {
+    fields: Record<string, unknown>;
+};
+export declare function fallbackMarkdown(fallback: JiraFallback): string;
+export declare function makeFallback(operation: JiraOperationName, reason: string, target: string, payload: unknown): JiraFallback;
+export declare function canRunLive(config: JiraConfig, operation: JiraOperationName): boolean;
+export declare class JiraRestClient {
+    private readonly config;
+    constructor(config: JiraConfig);
+    createIssue(ticket: JiraTicketInput): Promise<unknown>;
+    addComment(ticketKey: string, comment: string): Promise<unknown>;
+    safeUpdate(ticketKey: string, update: Partial<JiraTicketInput>): Promise<unknown>;
+    listTransitions(ticketKey: string): Promise<Array<{
+        id: string;
+        name: string;
+    }>>;
+    transitionIssue(ticketKey: string, transitionId: string): Promise<unknown>;
+    listIssueLinkTypes(): Promise<Array<{
+        id: string;
+        name: string;
+    }>>;
+    linkIssues(inwardIssue: string, outwardIssue: string, typeName: string): Promise<unknown>;
+    private request;
+}
+export declare function applyJiraOperation(options: JiraApplyOptions, config?: JiraConfig): Promise<JiraResult>;
+export declare function configSummary(config: JiraConfig): Record<string, unknown>;
+export declare function formatJiraDryRun(config?: JiraConfig): string;
+export declare function inferProjectRoot(fromPath: string): string;
+/** Backcompat helper for the initial package tests and thin CLI wrappers. */
+export declare function isJiraConfigured(config: JiraConfig): boolean;
+/** Backcompat payload shape: REST method/endpoint/body plus configured flag. */
+export declare function createIssuePayload(config: JiraConfig, ticket: JiraTicketInput): {
+    operation: 'create';
+    configured: boolean;
+    method: 'POST';
+    endpoint: string;
+    body: JiraRenderedIssue['payload'];
+};
+export declare function commentPayload(config: JiraConfig, ticketKey: string, comment: string): {
+    operation: 'comment';
+    configured: boolean;
+    method: 'POST';
+    endpoint: string;
+    body: {
+        body: string;
+    };
+};
+export declare function safeUpdatePayload(config: JiraConfig, ticketKey: string, update: Partial<JiraTicketInput>): {
+    operation: 'update';
+    configured: boolean;
+    method: 'PUT';
+    endpoint: string;
+    body: {
+        fields: Record<string, unknown>;
+    };
+};
+export declare function transitionFallbackPayload(config: JiraConfig, ticketKey: string, logicalState: string): {
+    operation: 'transition-fallback';
+    configured: false;
+    target: string;
+    body: JiraFallback;
+};
+export declare function linkFallbackPayload(config: JiraConfig, inwardIssue: string, outwardIssue: string): {
+    operation: 'link-fallback';
+    configured: false;
+    target: string;
+    body: JiraFallback;
+};

package/dist/src/jira.js

@@ -0,0 +1,492 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+const DEFAULT_TRANSITIONS = {
+    planned: 'To Do',
+    in_progress: 'In Progress',
+    review: 'In Review',
+    qa: 'QA',
+    done: 'Done',
+    blocked: 'Blocked',
+};
+const DEFAULT_OPERATIONS = {
+    create: true,
+    update: true,
+    comment: true,
+    transition: 'discover',
+    link: 'discover',
+};
+const SAFE_UPDATE_FIELDS = new Set(['summary', 'description', 'labels', 'components', 'priority']);
+export function loadDotEnv(cwd = process.cwd()) {
+    const path = join(cwd, '.env');
+    if (!existsSync(path))
+        return {};
+    const env = {};
+    for (const rawLine of readFileSync(path, 'utf8').split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const equals = line.indexOf('=');
+        if (equals === -1)
+            continue;
+        const key = line.slice(0, equals).trim();
+        const value = line.slice(equals + 1).trim().replace(/^['"]|['"]$/g, '');
+        if (key)
+            env[key] = value;
+    }
+    return env;
+}
+export function discoverJiraConfig(options = {}, envArg) {
+    const normalized = typeof options === 'string' ? { cwd: options, env: envArg } : options;
+    const cwd = normalized.cwd ?? process.cwd();
+    const processEnv = normalized.env ?? process.env;
+    const dotEnv = loadDotEnv(cwd);
+    const mergedEnv = { ...dotEnv, ...processEnv };
+    const external = readExternalConfig(cwd, mergedEnv, normalized.configPath);
+    const jira = normalizeExternalJira(external.config);
+    const source = [...external.source];
+    const config = {
+        tracker: 'jira',
+        mode: normalizeMode(jira.mode ?? mergedEnv.JIRA_MODE ?? 'dry-run'),
+        baseUrl: resolveEnvRef(jira.baseUrl ?? jira.siteUrl, mergedEnv) ?? mergedEnv.JIRA_BASE_URL ?? mergedEnv.JIRA_SITE_URL,
+        email: resolveEnvRef(jira.email ?? jira.user, mergedEnv) ?? mergedEnv.JIRA_EMAIL ?? mergedEnv.JIRA_USER,
+        apiToken: resolveEnvRef(jira.apiToken ?? jira.auth ?? jira.token, mergedEnv) ?? mergedEnv.JIRA_API_TOKEN ?? mergedEnv.JIRA_TOKEN,
+        projectKey: resolveEnvRef(jira.projectKey ?? jira.project, mergedEnv) ?? mergedEnv.JIRA_PROJECT_KEY,
+        defaultIssueType: String(jira.defaultIssueType ?? mergedEnv.JIRA_DEFAULT_ISSUE_TYPE ?? 'Task'),
+        operations: { ...DEFAULT_OPERATIONS, ...(jira.operations ?? {}) },
+        transitions: { ...DEFAULT_TRANSITIONS, ...(jira.transitions ?? {}) },
+        linkType: resolveEnvRef(jira.linkType, mergedEnv) ?? mergedEnv.JIRA_LINK_TYPE,
+        labels: normalizeList(jira.labels ?? mergedEnv.JIRA_LABELS),
+        components: normalizeList(jira.components ?? mergedEnv.JIRA_COMPONENTS),
+        priority: resolveEnvRef(jira.priority, mergedEnv) ?? mergedEnv.JIRA_PRIORITY,
+        source,
+    };
+    config.siteUrl = config.baseUrl;
+    const overrides = normalized.overrides ?? {};
+    return {
+        ...config,
+        ...overrides,
+        operations: { ...config.operations, ...(overrides.operations ?? {}) },
+        transitions: { ...config.transitions, ...(overrides.transitions ?? {}) },
+        siteUrl: overrides.siteUrl ?? overrides.baseUrl ?? config.siteUrl,
+        source: [...config.source, ...(overrides.source ?? [])],
+    };
+}
+function readExternalConfig(cwd, env, explicitPath) {
+    const candidates = [
+        explicitPath,
+        env.OH_MY_COPILOT_JIRA_CONFIG,
+        env.JIRA_CONFIG_FILE,
+        join(homedir(), '.config', 'oh-my-copilot', 'jira.json'),
+        join(homedir(), '.config', 'oh-my-copilot', 'config.json'),
+        join(homedir(), '.oh-my-copilot', 'jira.json'),
+        join(cwd, '.oh-my-copilot.jira.json'),
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        const path = isAbsolute(candidate) ? candidate : resolve(cwd, candidate);
+        if (!existsSync(path))
+            continue;
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return { config: parsed, source: [path] };
+    }
+    return { config: {}, source: ['env/.env'] };
+}
+function normalizeExternalJira(raw) {
+    if (raw.jira && typeof raw.jira === 'object')
+        return raw.jira;
+    return raw;
+}
+function normalizeMode(value) {
+    return value === 'live' ? 'live' : 'dry-run';
+}
+function resolveEnvRef(value, env) {
+    if (typeof value !== 'string')
+        return undefined;
+    if (!value.startsWith('env:'))
+        return value;
+    return env[value.slice('env:'.length)];
+}
+function normalizeList(value) {
+    if (Array.isArray(value))
+        return value.map(String).filter(Boolean);
+    if (typeof value === 'string')
+        return value.split(',').map((item) => item.trim()).filter(Boolean);
+    return undefined;
+}
+export function ticketFromMarkdown(markdown, fallbackSummary = 'Planned work') {
+    const lines = markdown.split(/\r?\n/);
+    const heading = lines.find((line) => /^#\s+/.test(line))?.replace(/^#\s+/, '').trim();
+    const firstText = lines.find((line) => line.trim() && !line.trim().startsWith('#'))?.trim();
+    const acceptanceCriteria = extractListSection(lines, /acceptance criteria/i);
+    const implementationNotes = extractListSection(lines, /implementation notes|notes/i);
+    return {
+        summary: heading || firstText || fallbackSummary,
+        description: markdown.trim() || fallbackSummary,
+        acceptanceCriteria,
+        implementationNotes,
+    };
+}
+function extractListSection(lines, headerPattern) {
+    const start = lines.findIndex((line) => headerPattern.test(line));
+    if (start === -1)
+        return undefined;
+    const items = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^#{1,6}\s+/.test(line) && items.length)
+            break;
+        const match = line.match(/^\s*[-*]\s+(.*)$/);
+        if (match)
+            items.push(match[1].trim());
+    }
+    return items.length ? items : undefined;
+}
+export function readTicketInput(path) {
+    const text = readFileSync(path, 'utf8');
+    if (/\.json$/i.test(path))
+        return JSON.parse(text);
+    return ticketFromMarkdown(text, `Jira ticket from ${path}`);
+}
+export function renderCreateIssue(ticket, config = discoverJiraConfig()) {
+    const projectKey = config.projectKey ?? '<PROJECT-KEY>';
+    const fields = {
+        project: { key: projectKey },
+        issuetype: { name: ticket.issueType ?? config.defaultIssueType },
+        summary: ticket.summary,
+        description: composeDescription(ticket),
+    };
+    const labels = [...(config.labels ?? []), ...(ticket.labels ?? [])];
+    if (labels.length)
+        fields.labels = unique(labels);
+    const components = ticket.components ?? config.components;
+    if (components?.length)
+        fields.components = components.map((name) => ({ name }));
+    const priority = ticket.priority ?? config.priority;
+    if (priority)
+        fields.priority = { name: priority };
+    return {
+        operation: 'create',
+        endpoint: '/rest/api/3/issue',
+        payload: { fields },
+    };
+}
+export function renderComment(comment) {
+    return { body: comment };
+}
+export function renderSafeUpdate(update, config = discoverJiraConfig()) {
+    const fields = {};
+    if (update.summary)
+        fields.summary = update.summary;
+    if (update.description || update.acceptanceCriteria || update.implementationNotes) {
+        fields.description = composeDescription({
+            summary: update.summary ?? 'Update',
+            description: update.description ?? '',
+            acceptanceCriteria: update.acceptanceCriteria,
+            implementationNotes: update.implementationNotes,
+        });
+    }
+    const labels = update.labels;
+    if (labels)
+        fields.labels = unique([...(config.labels ?? []), ...labels]);
+    const components = update.components;
+    if (components)
+        fields.components = components.map((name) => ({ name }));
+    const priority = update.priority;
+    if (priority)
+        fields.priority = { name: priority };
+    for (const key of Object.keys(fields)) {
+        if (!SAFE_UPDATE_FIELDS.has(key))
+            delete fields[key];
+    }
+    return { fields };
+}
+function composeDescription(ticket) {
+    const sections = [ticket.description.trim()];
+    if (ticket.acceptanceCriteria?.length) {
+        sections.push(['Acceptance Criteria', ...ticket.acceptanceCriteria.map((item) => `- ${item}`)].join('\n'));
+    }
+    if (ticket.implementationNotes?.length) {
+        sections.push(['Implementation Notes', ...ticket.implementationNotes.map((item) => `- ${item}`)].join('\n'));
+    }
+    return sections.filter(Boolean).join('\n\n');
+}
+function unique(items) {
+    return [...new Set(items.map((item) => item.trim()).filter(Boolean))];
+}
+export function fallbackMarkdown(fallback) {
+    return [
+        `## Jira fallback: ${fallback.operation}`,
+        `Reason: ${fallback.reason}`,
+        `Target: ${fallback.target}`,
+        'Payload:',
+        '```json',
+        JSON.stringify(fallback.payload, null, 2),
+        '```',
+        'Human action:',
+        fallback.humanAction,
+    ].join('\n');
+}
+export function makeFallback(operation, reason, target, payload) {
+    const action = humanActionFor(operation, target);
+    return { operation, reason, target, payload, humanAction: action };
+}
+function humanActionFor(operation, target) {
+    switch (operation) {
+        case 'create':
+            return 'Create a Jira issue with the payload above.';
+        case 'comment':
+            return `Add the comment payload above to ${target}.`;
+        case 'update':
+            return `Update only the safe fields shown above on ${target}.`;
+        case 'transition':
+            return `Choose the matching Jira workflow transition for ${target}; do not guess an id.`;
+        case 'link':
+            return `Create the Jira issue link for ${target} only after confirming the link type exists.`;
+    }
+}
+export function canRunLive(config, operation) {
+    if (config.mode !== 'live')
+        return false;
+    if (!config.baseUrl || !config.email || !config.apiToken)
+        return false;
+    if (operation === 'create' && !config.projectKey)
+        return false;
+    const configured = config.operations[operation];
+    return configured === true || configured === 'discover';
+}
+export class JiraRestClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async createIssue(ticket) {
+        return this.request('/rest/api/3/issue', { method: 'POST', body: renderCreateIssue(ticket, this.config).payload });
+    }
+    async addComment(ticketKey, comment) {
+        return this.request(`/rest/api/3/issue/${encodeURIComponent(ticketKey)}/comment`, { method: 'POST', body: renderComment(comment) });
+    }
+    async safeUpdate(ticketKey, update) {
+        return this.request(`/rest/api/3/issue/${encodeURIComponent(ticketKey)}`, { method: 'PUT', body: renderSafeUpdate(update, this.config) });
+    }
+    async listTransitions(ticketKey) {
+        const response = await this.request(`/rest/api/3/issue/${encodeURIComponent(ticketKey)}/transitions`, { method: 'GET' });
+        return response.transitions ?? [];
+    }
+    async transitionIssue(ticketKey, transitionId) {
+        return this.request(`/rest/api/3/issue/${encodeURIComponent(ticketKey)}/transitions`, {
+            method: 'POST',
+            body: { transition: { id: transitionId } },
+        });
+    }
+    async listIssueLinkTypes() {
+        const response = await this.request('/rest/api/3/issueLinkType', { method: 'GET' });
+        return response.issueLinkTypes ?? [];
+    }
+    async linkIssues(inwardIssue, outwardIssue, typeName) {
+        return this.request('/rest/api/3/issueLink', {
+            method: 'POST',
+            body: { type: { name: typeName }, inwardIssue: { key: inwardIssue }, outwardIssue: { key: outwardIssue } },
+        });
+    }
+    async request(path, init) {
+        if (!this.config.baseUrl || !this.config.email || !this.config.apiToken) {
+            throw new Error('Jira config is incomplete');
+        }
+        const response = await fetch(new URL(path, this.config.baseUrl), {
+            method: init.method,
+            headers: {
+                authorization: `Basic ${Buffer.from(`${this.config.email}:${this.config.apiToken}`).toString('base64')}`,
+                accept: 'application/json',
+                'content-type': 'application/json',
+            },
+            body: init.body === undefined ? undefined : JSON.stringify(init.body),
+        });
+        const text = await response.text();
+        const data = text ? JSON.parse(text) : undefined;
+        if (!response.ok)
+            throw new Error(`Jira ${init.method} ${path} failed: ${response.status} ${text}`);
+        return data;
+    }
+}
+export async function applyJiraOperation(options, config = discoverJiraConfig()) {
+    const dryRun = options.dryRun || !canRunLive(config, options.operation);
+    const target = options.target ?? 'new issue';
+    const payload = payloadForOperation(options, config);
+    if (dryRun) {
+        return {
+            ok: true,
+            live: false,
+            operation: options.operation,
+            fallback: makeFallback(options.operation, fallbackReason(config, options.operation, options.dryRun), target, payload),
+        };
+    }
+    const client = new JiraRestClient(config);
+    try {
+        if (options.operation === 'create') {
+            return { ok: true, live: true, operation: 'create', response: await client.createIssue(requireTicket(options.ticket)) };
+        }
+        if (options.operation === 'comment') {
+            return { ok: true, live: true, operation: 'comment', response: await client.addComment(requireTarget(options.target), options.comment ?? '') };
+        }
+        if (options.operation === 'update') {
+            return { ok: true, live: true, operation: 'update', response: await client.safeUpdate(requireTarget(options.target), options.update ?? options.ticket ?? {}) };
+        }
+        if (options.operation === 'transition') {
+            const transition = await resolveDiscoveredTransition(client, requireTarget(options.target), options.transitionState ?? 'done', config);
+            if (!transition)
+                throw new DiscoveryRequiredError('No exact configured/discovered Jira transition matched');
+            return { ok: true, live: true, operation: 'transition', response: await client.transitionIssue(requireTarget(options.target), transition.id) };
+        }
+        if (options.operation === 'link') {
+            const linkType = await resolveDiscoveredLinkType(client, config);
+            if (!linkType)
+                throw new DiscoveryRequiredError('No configured Jira link type was discovered');
+            return { ok: true, live: true, operation: 'link', response: await client.linkIssues(requireTarget(options.target), requireTarget(options.linkTarget), linkType.name) };
+        }
+    }
+    catch (error) {
+        return {
+            ok: false,
+            live: false,
+            operation: options.operation,
+            fallback: makeFallback(options.operation, error instanceof Error ? error.message : String(error), target, payload),
+        };
+    }
+    return {
+        ok: false,
+        live: false,
+        operation: options.operation,
+        fallback: makeFallback(options.operation, `Unsupported Jira operation: ${options.operation}`, target, payload),
+    };
+}
+function payloadForOperation(options, config) {
+    switch (options.operation) {
+        case 'create': return renderCreateIssue(requireTicket(options.ticket), config).payload;
+        case 'comment': return renderComment(options.comment ?? '');
+        case 'update': return renderSafeUpdate(options.update ?? options.ticket ?? {}, config);
+        case 'transition': return { transition: { logicalState: options.transitionState ?? 'done', configuredName: config.transitions[options.transitionState ?? 'done'] } };
+        case 'link': return { type: { name: config.linkType ?? '<discover>' }, inwardIssue: { key: options.target }, outwardIssue: { key: options.linkTarget } };
+    }
+}
+function fallbackReason(config, operation, explicitDryRun) {
+    if (explicitDryRun)
+        return 'dry-run requested; no live Jira write was attempted';
+    if (config.mode !== 'live')
+        return 'Jira mode is dry-run; no live Jira write was attempted';
+    if (!config.baseUrl || !config.email || !config.apiToken)
+        return 'Jira credentials/config are incomplete';
+    if (operation === 'create' && !config.projectKey)
+        return 'Jira project key is missing; live create was not attempted';
+    if (!config.operations[operation])
+        return `Jira ${operation} operation is disabled in config`;
+    return `Jira ${operation} requires discovery or live execution was not available`;
+}
+async function resolveDiscoveredTransition(client, ticketKey, logicalState, config) {
+    const wanted = config.transitions[logicalState] ?? logicalState;
+    const transitions = await client.listTransitions(ticketKey);
+    return transitions.find((transition) => transition.name === wanted || transition.id === wanted);
+}
+async function resolveDiscoveredLinkType(client, config) {
+    if (!config.linkType)
+        return undefined;
+    const linkTypes = await client.listIssueLinkTypes();
+    return linkTypes.find((type) => type.name === config.linkType || type.id === config.linkType);
+}
+class DiscoveryRequiredError extends Error {
+}
+function requireTicket(ticket) {
+    if (!ticket)
+        throw new Error('Jira ticket input is required');
+    return ticket;
+}
+function requireTarget(target) {
+    if (!target)
+        throw new Error('Jira ticket key/target is required');
+    return target;
+}
+export function configSummary(config) {
+    return {
+        tracker: config.tracker,
+        mode: config.mode,
+        baseUrlConfigured: Boolean(config.baseUrl),
+        emailConfigured: Boolean(config.email),
+        tokenConfigured: Boolean(config.apiToken),
+        projectKey: config.projectKey,
+        defaultIssueType: config.defaultIssueType,
+        operations: config.operations,
+        source: config.source,
+    };
+}
+export function formatJiraDryRun(config = discoverJiraConfig()) {
+    const sampleTicket = {
+        issueType: config.defaultIssueType,
+        summary: 'Dry-run Jira issue',
+        description: 'Generated by oh-my-copilot jira:dry-run.',
+        labels: ['oh-my-copilot', 'dry-run'],
+    };
+    const create = createIssuePayload(config, sampleTicket);
+    const comment = commentPayload(config, 'OMC-123', 'Verification: dry-run evidence collected.');
+    const update = safeUpdatePayload(config, 'OMC-123', { summary: 'Dry-run Jira issue update', labels: ['verified'] });
+    const transition = transitionFallbackPayload(config, 'OMC-123', 'Done');
+    const link = linkFallbackPayload(config, 'OMC-123', 'OMC-124');
+    return JSON.stringify({
+        ok: true,
+        dryRun: true,
+        jira: configSummary(config),
+        operations: { create, comment, update, transition, link },
+    }, null, 2);
+}
+export function inferProjectRoot(fromPath) {
+    return dirname(resolve(fromPath));
+}
+/** Backcompat helper for the initial package tests and thin CLI wrappers. */
+export function isJiraConfigured(config) {
+    return Boolean((config.baseUrl ?? config.siteUrl) && config.email && config.apiToken && config.projectKey);
+}
+/** Backcompat payload shape: REST method/endpoint/body plus configured flag. */
+export function createIssuePayload(config, ticket) {
+    const rendered = renderCreateIssue(ticket, config);
+    return {
+        operation: 'create',
+        configured: isJiraConfigured(config),
+        method: 'POST',
+        endpoint: rendered.endpoint,
+        body: rendered.payload,
+    };
+}
+export function commentPayload(config, ticketKey, comment) {
+    return {
+        operation: 'comment',
+        configured: isJiraConfigured(config),
+        method: 'POST',
+        endpoint: `/rest/api/3/issue/${encodeURIComponent(ticketKey)}/comment`,
+        body: renderComment(comment),
+    };
+}
+export function safeUpdatePayload(config, ticketKey, update) {
+    return {
+        operation: 'update',
+        configured: isJiraConfigured(config),
+        method: 'PUT',
+        endpoint: `/rest/api/3/issue/${encodeURIComponent(ticketKey)}`,
+        body: renderSafeUpdate(update, config),
+    };
+}
+export function transitionFallbackPayload(config, ticketKey, logicalState) {
+    const payload = { transition: { logicalState, configuredName: config.transitions[logicalState] ?? logicalState } };
+    return {
+        operation: 'transition-fallback',
+        configured: false,
+        target: ticketKey,
+        body: makeFallback('transition', 'transition requires Jira discovery; no transition id was guessed', ticketKey, payload),
+    };
+}
+export function linkFallbackPayload(config, inwardIssue, outwardIssue) {
+    const payload = { type: { name: config.linkType ?? '<discover>' }, inwardIssue: { key: inwardIssue }, outwardIssue: { key: outwardIssue } };
+    return {
+        operation: 'link-fallback',
+        configured: false,
+        target: `${inwardIssue} -> ${outwardIssue}`,
+        body: makeFallback('link', 'link requires Jira link type discovery; no link type was guessed', `${inwardIssue} -> ${outwardIssue}`, payload),
+    };
+}
+//# sourceMappingURL=jira.js.map