@credal/actions 0.2.202 → 0.2.205

package/dist/actions/providers/google-oauth/createNewGoogleDoc.js

@@ -1,97 +1,6 @@
 import { axiosClient } from "../../util/axiosClient.js";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
-/**
- * Parses HTML content and converts it to Google Docs API batch update requests
- */
-function parseHtmlToDocRequests(htmlContent) {
-    const requests = [];
-    let currentIndex = 1;
-    // Strip HTML tags and extract text with basic formatting
-    const textWithFormatting = parseHtmlContent(htmlContent);
-    for (const item of textWithFormatting) {
-        // Insert text
-        requests.push({
-            insertText: {
-                location: { index: currentIndex },
-                text: item.text,
-            },
-        });
-        // Apply formatting if present
-        if (item.formatting && Object.keys(item.formatting).length > 0) {
-            const endIndex = currentIndex + item.text.length;
-            requests.push({
-                updateTextStyle: {
-                    range: { startIndex: currentIndex, endIndex },
-                    textStyle: item.formatting,
-                    fields: Object.keys(item.formatting).join(","),
-                },
-            });
-        }
-        currentIndex += item.text.length;
-    }
-    return requests;
-}
-/**
- * Basic HTML parser that extracts text and formatting
- */
-function parseHtmlContent(html) {
-    const result = [];
-    // Handle line breaks
-    html = html.replace(/<br\s*\/?>/gi, "\n");
-    html = html.replace(/<\/p>/gi, "\n");
-    html = html.replace(/<p[^>]*>/gi, "");
-    // Simple regex-based parsing for basic HTML tags
-    const segments = html.split(/(<[^>]+>)/);
-    const currentFormatting = {};
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        if (segment.startsWith("<")) {
-            // This is an HTML tag
-            if (segment.match(/<\s*b\s*>/i) || segment.match(/<\s*strong\s*>/i)) {
-                currentFormatting.bold = true;
-            }
-            else if (segment.match(/<\/\s*b\s*>/i) || segment.match(/<\/\s*strong\s*>/i)) {
-                delete currentFormatting.bold;
-            }
-            else if (segment.match(/<\s*i\s*>/i) || segment.match(/<\s*em\s*>/i)) {
-                currentFormatting.italic = true;
-            }
-            else if (segment.match(/<\/\s*i\s*>/i) || segment.match(/<\/\s*em\s*>/i)) {
-                delete currentFormatting.italic;
-            }
-            else if (segment.match(/<\s*u\s*>/i)) {
-                currentFormatting.underline = true;
-            }
-            else if (segment.match(/<\/\s*u\s*>/i)) {
-                delete currentFormatting.underline;
-            }
-            else if (segment.match(/<\s*h[1-6]\s*>/i)) {
-                const headingLevel = segment.match(/<\s*h([1-6])\s*>/i)?.[1];
-                currentFormatting.fontSize = { magnitude: 18 - (parseInt(headingLevel || "1") - 1) * 2, unit: "PT" };
-                currentFormatting.bold = true;
-            }
-            else if (segment.match(/<\/\s*h[1-6]\s*>/i)) {
-                delete currentFormatting.fontSize;
-                delete currentFormatting.bold;
-            }
-        }
-        else if (segment.trim()) {
-            // This is text content
-            result.push({
-                text: segment,
-                formatting: Object.keys(currentFormatting).length > 0 ? { ...currentFormatting } : undefined,
-            });
-        }
-    }
-    // If no formatted content was found, return the plain text
-    if (result.length === 0) {
-        const plainText = html.replace(/<[^>]*>/g, "");
-        if (plainText.trim()) {
-            result.push({ text: plainText });
-        }
-    }
-    return result;
-}
+import { resolveContentFormat, contentToDocRequests } from "./utils/googleDocsMarkdown.js";
 /**
  * Creates a new Google Doc document using OAuth authentication
  */
@@ -99,8 +8,9 @@ const createNewGoogleDoc = async ({ params, authParams, }) => {
     if (!authParams.authToken) {
         throw new Error(MISSING_AUTH_TOKEN);
     }
-    const { title, content, usesHtml } = params;
+    const { title, content, usesHtml, contentFormat } = params;
     const baseApiUrl = "https://docs.googleapis.com/v1/documents";
+    const resolvedContentFormat = resolveContentFormat({ contentFormat, usesHtml });
     // Create the document with the provided title
     const response = await axiosClient.post(baseApiUrl, { title }, {
         headers: {
@@ -111,36 +21,13 @@ const createNewGoogleDoc = async ({ params, authParams, }) => {
     // If content is provided, update the document body with the content
     if (content) {
         const documentId = response.data.documentId;
-        if (usesHtml) {
-            // Parse HTML content and create requests for rich text formatting
-            const requests = parseHtmlToDocRequests(content);
-            await axiosClient.post(`${baseApiUrl}/${documentId}:batchUpdate`, { requests }, {
-                headers: {
-                    Authorization: `Bearer ${authParams.authToken}`,
-                    "Content-Type": "application/json",
-                },
-            });
-        }
-        else {
-            // Add plain text content to the document
-            await axiosClient.post(`${baseApiUrl}/${documentId}:batchUpdate`, {
-                requests: [
-                    {
-                        insertText: {
-                            location: {
-                                index: 1, // Insert at the beginning of the document
-                            },
-                            text: content,
-                        },
-                    },
-                ],
-            }, {
-                headers: {
-                    Authorization: `Bearer ${authParams.authToken}`,
-                    "Content-Type": "application/json",
-                },
-            });
-        }
+        const requests = contentToDocRequests({ content, format: resolvedContentFormat });
+        await axiosClient.post(`${baseApiUrl}/${documentId}:batchUpdate`, { requests }, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+                "Content-Type": "application/json",
+            },
+        });
     }
     return {
         documentId: response.data.documentId,

package/dist/actions/providers/google-oauth/utils/googleDocsMarkdown.d.ts

@@ -0,0 +1,88 @@
+import type { docs_v1 } from "@googleapis/docs";
+export type GoogleDocContentFormat = "plain" | "html" | "markdown";
+/** Maps heading level (1–6) to Google Docs namedStyleType. */
+declare const HEADING_STYLE_MAP: {
+    readonly 1: "HEADING_1";
+    readonly 2: "HEADING_2";
+    readonly 3: "HEADING_3";
+    readonly 4: "HEADING_4";
+    readonly 5: "HEADING_5";
+    readonly 6: "HEADING_6";
+};
+/** Google Docs bullet presets used by createParagraphBullets. */
+declare const BULLET_PRESET: {
+    readonly UNORDERED: "BULLET_DISC_CIRCLE_SQUARE";
+    readonly ORDERED: "NUMBERED_DECIMAL_ALPHA_ROMAN";
+};
+type BulletPreset = (typeof BULLET_PRESET)[keyof typeof BULLET_PRESET];
+type HeadingLevel = keyof typeof HEADING_STYLE_MAP;
+/**
+ * Intermediate representation bridging HTML parsing and Google Docs API request generation.
+ *
+ * The Google Docs API doesn't accept HTML or Markdown directly — it requires explicit
+ * batch requests (insertText, updateTextStyle, updateParagraphStyle, createParagraphBullets).
+ * This IR lets us decouple the two concerns:
+ *   1. parseHtmlContent() walks HTML and produces an array of these segments
+ *   2. parseHtmlToDocRequests() transforms them into the specific API requests Google expects
+ */
+interface TextWithFormatting {
+    text: string;
+    formatting?: docs_v1.Schema$TextStyle;
+    bulletPreset?: BulletPreset;
+    headingLevel?: HeadingLevel;
+}
+/** Wraps plain text in a single `insertText` request at document index 1 (start of body). */
+export declare function plainTextToDocRequests(content: string): docs_v1.Schema$Request[];
+/**
+ * Parses an HTML string into an array of `TextWithFormatting` segments.
+ *
+ * Strategy: split on HTML tags, walk segments sequentially, and maintain a mutable
+ * formatting state (`currentFormatting`, `listStack`, `currentHeadingLevel`).
+ * Opening tags push state (e.g. `<b>` sets `bold: true`), closing tags pop it.
+ * Non-tag segments are emitted with a snapshot of the current state.
+ *
+ * Supported elements: `<b>/<strong>`, `<i>/<em>`, `<u>`, `<code>`, `<a href>`,
+ * `<ul>/<ol>/<li>`, `<h1>`–`<h6>`, `<p>`, `<br>`.
+ *
+ * @example
+ *   parseHtmlContent("<p><b>hello</b> world</p>")
+ *   // → [{ text: "hello", formatting: { bold: true } }, { text: " world" }, { text: "\n" }]
+ */
+export declare function parseHtmlContent(html: string): TextWithFormatting[];
+/**
+ * Converts an HTML string into Google Docs API batch requests.
+ *
+ * Pipeline: HTML → `parseHtmlContent()` → TextWithFormatting[] → four request buckets:
+ *   1. `insertText`            – insert each text segment sequentially starting at index 1
+ *   2. `updateTextStyle`       – apply bold/italic/underline/link/code formatting
+ *   3. `updateParagraphStyle`  – apply heading levels (HEADING_1–HEADING_6)
+ *   4. `createParagraphBullets`– apply bullet/numbered list presets
+ *
+ * Requests are ordered inserts-first so that character indices remain valid when
+ * style/bullet/heading requests reference them (styles are applied after all text is inserted).
+ */
+export declare function parseHtmlToDocRequests(htmlContent: string): docs_v1.Schema$Request[];
+/**
+ * Converts a Markdown string into Google Docs API batch requests.
+ *
+ * Two-step pipeline: Markdown → HTML (via `marked`) → Docs requests (via `parseHtmlToDocRequests`).
+ * Falls back to plain-text insertion if `marked` throws.
+ */
+export declare function markdownToDocRequests(markdown: string): docs_v1.Schema$Request[];
+/**
+ * Resolves which content format to use, with backwards-compatible `usesHtml` fallback.
+ * Priority: explicit `contentFormat` > legacy `usesHtml: true` → "html" > default "plain".
+ */
+export declare function resolveContentFormat(args: {
+    contentFormat?: GoogleDocContentFormat;
+    usesHtml?: boolean;
+}): GoogleDocContentFormat;
+/**
+ * Dispatches content to the appropriate converter based on format.
+ * Single entry point so callers don't need to branch on format themselves.
+ */
+export declare function contentToDocRequests(args: {
+    content: string;
+    format: GoogleDocContentFormat;
+}): docs_v1.Schema$Request[];
+export {};

package/dist/actions/providers/google-oauth/utils/googleDocsMarkdown.js

@@ -0,0 +1,350 @@
+import { marked } from "marked";
+/** Maps heading level (1–6) to Google Docs namedStyleType. */
+const HEADING_STYLE_MAP = {
+    1: "HEADING_1",
+    2: "HEADING_2",
+    3: "HEADING_3",
+    4: "HEADING_4",
+    5: "HEADING_5",
+    6: "HEADING_6",
+};
+/** Google Docs bullet presets used by createParagraphBullets. */
+const BULLET_PRESET = {
+    UNORDERED: "BULLET_DISC_CIRCLE_SQUARE",
+    ORDERED: "NUMBERED_DECIMAL_ALPHA_ROMAN",
+};
+/** Replaces common HTML entities (`&`, `<`, ` `, etc.) with their literal characters. */
+function decodeHtmlEntities(text) {
+    return text
+        .replace(/ /g, " ")
+        .replace(/&/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&mdash;/g, "\u2014")
+        .replace(/&ndash;/g, "\u2013")
+        .replace(/&hellip;/g, "\u2026")
+        .replace(/&copy;/g, "\u00A9")
+        .replace(/&trade;/g, "\u2122")
+        .replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number(code)));
+}
+/** Maps a heading level (1–6) to the corresponding Google Docs `namedStyleType` (e.g. 3 → "HEADING_3"). */
+function getNamedStyleType(level) {
+    return HEADING_STYLE_MAP[level] ?? "HEADING_1";
+}
+/**
+ * Builds the `fields` mask required by `updateTextStyle` from the keys present in a TextStyle.
+ * E.g. `{ bold: true, link: { url: "..." } }` → `"bold,link"`.
+ */
+function fieldMaskFromTextStyle(style) {
+    return Object.keys(style).join(",");
+}
+const ALLOWED_URL_SCHEMES = /^https?:\/\//i;
+/** Returns true if the URL uses a safe scheme (http/https). Rejects javascript:, data:, etc. */
+function isSafeUrl(url) {
+    return ALLOWED_URL_SCHEMES.test(url.trim());
+}
+/** Removes all HTML tags and decodes entities. Used as a last-resort fallback when parsing yields no segments. */
+function stripHtmlTags(content) {
+    return decodeHtmlEntities(content.replace(/<[^>]*>/g, ""));
+}
+/** Wraps plain text in a single `insertText` request at document index 1 (start of body). */
+export function plainTextToDocRequests(content) {
+    return [
+        {
+            insertText: {
+                location: { index: 1 },
+                text: content,
+            },
+        },
+    ];
+}
+/**
+ * Parses an HTML string into an array of `TextWithFormatting` segments.
+ *
+ * Strategy: split on HTML tags, walk segments sequentially, and maintain a mutable
+ * formatting state (`currentFormatting`, `listStack`, `currentHeadingLevel`).
+ * Opening tags push state (e.g. `<b>` sets `bold: true`), closing tags pop it.
+ * Non-tag segments are emitted with a snapshot of the current state.
+ *
+ * Supported elements: `<b>/<strong>`, `<i>/<em>`, `<u>`, `<code>`, `<a href>`,
+ * `<ul>/<ol>/<li>`, `<h1>`–`<h6>`, `<p>`, `<br>`.
+ *
+ * @example
+ *   parseHtmlContent("<p><b>hello</b> world</p>")
+ *   // → [{ text: "hello", formatting: { bold: true } }, { text: " world" }, { text: "\n" }]
+ */
+export function parseHtmlContent(html) {
+    // Normalize <br> to newlines, then split into alternating [text, tag, text, tag, ...] segments.
+    // The capturing group in the regex keeps the tags in the result array.
+    const segments = html
+        .replace(/<br\s*\/?>/gi, "\n")
+        .split(/(<[^>]+>)/)
+        .filter(segment => segment.length > 0);
+    const result = [];
+    // Mutable state that tracks currently active formatting as we walk through segments.
+    // Opening tags add properties, closing tags delete them.
+    const currentFormatting = {};
+    // Stack to support nested lists — top of stack is the active bullet preset
+    const listStack = [];
+    let currentHeadingLevel;
+    let insidePre = false;
+    for (const segment of segments) {
+        // --- Text node: emit with a snapshot of the current formatting state ---
+        if (!segment.startsWith("<")) {
+            const decodedText = decodeHtmlEntities(segment);
+            if (!decodedText) {
+                continue;
+            }
+            // Skip newline-only text nodes — these are HTML formatting artifacts
+            // We preserve spaces (e.g. " " between inline elements like </b> and <a>).
+            if (/^\n+$/.test(decodedText)) {
+                continue;
+            }
+            result.push({
+                text: decodedText,
+                formatting: Object.keys(currentFormatting).length > 0 ? { ...currentFormatting } : undefined,
+                bulletPreset: listStack[listStack.length - 1],
+                headingLevel: currentHeadingLevel,
+            });
+            continue;
+        }
+        // --- Character-level formatting: toggle on open, remove on close ---
+        if (segment.match(/<\s*b\s*>/i) || segment.match(/<\s*strong\s*>/i)) {
+            currentFormatting.bold = true;
+            continue;
+        }
+        if (segment.match(/<\/\s*b\s*>/i) || segment.match(/<\/\s*strong\s*>/i)) {
+            delete currentFormatting.bold;
+            continue;
+        }
+        if (segment.match(/<\s*i\s*>/i) || segment.match(/<\s*em\s*>/i)) {
+            currentFormatting.italic = true;
+            continue;
+        }
+        if (segment.match(/<\/\s*i\s*>/i) || segment.match(/<\/\s*em\s*>/i)) {
+            delete currentFormatting.italic;
+            continue;
+        }
+        if (segment.match(/<\s*u\s*>/i)) {
+            currentFormatting.underline = true;
+            continue;
+        }
+        if (segment.match(/<\/\s*u\s*>/i)) {
+            delete currentFormatting.underline;
+            continue;
+        }
+        // Code: rendered as Courier New
+        if (segment.match(/<\s*code[^>]*>/i)) {
+            currentFormatting.weightedFontFamily = { fontFamily: "Courier New" };
+            continue;
+        }
+        if (segment.match(/<\/\s*code\s*>/i)) {
+            // Only clear monospace if we're not inside a <pre> block —
+            // <pre><code>...</code>text</pre> should keep text monospaced
+            if (!insidePre) {
+                delete currentFormatting.weightedFontFamily;
+            }
+            continue;
+        }
+        // Pre-formatted blocks: same monospace treatment as <code>, with trailing newline on close
+        if (segment.match(/<\s*pre[^>]*>/i)) {
+            insidePre = true;
+            currentFormatting.weightedFontFamily = { fontFamily: "Courier New" };
+            continue;
+        }
+        if (segment.match(/<\/\s*pre\s*>/i)) {
+            insidePre = false;
+            delete currentFormatting.weightedFontFamily;
+            result.push({ text: "\n" });
+            continue;
+        }
+        // --- Lists: stack-based to handle nesting (e.g. <ul> inside <ol>) ---
+        if (segment.match(/<\s*ul[^>]*>/i)) {
+            listStack.push(BULLET_PRESET.UNORDERED);
+            continue;
+        }
+        if (segment.match(/<\s*ol[^>]*>/i)) {
+            listStack.push(BULLET_PRESET.ORDERED);
+            continue;
+        }
+        if (segment.match(/<\/\s*(ul|ol)\s*>/i)) {
+            listStack.pop();
+            result.push({ text: "\n" });
+            continue;
+        }
+        // <li> open is a no-op; </li> emits a newline tagged with the current bullet preset
+        // so parseHtmlToDocRequests knows which lines to apply createParagraphBullets to
+        if (segment.match(/<\s*li[^>]*>/i)) {
+            continue;
+        }
+        if (segment.match(/<\/\s*li\s*>/i)) {
+            result.push({
+                text: "\n",
+                bulletPreset: listStack[listStack.length - 1],
+            });
+            continue;
+        }
+        // --- Block-level elements: emit newlines for paragraph breaks ---
+        if (segment.match(/<\s*p[^>]*>/i)) {
+            continue;
+        }
+        if (segment.match(/<\/\s*p\s*>/i)) {
+            result.push({ text: "\n" });
+            continue;
+        }
+        // --- Headings: set level on open, clear on close + emit newline ---
+        const headingStart = segment.match(/<\s*h([1-6])[^>]*>/i);
+        if (headingStart) {
+            currentHeadingLevel = Number.parseInt(headingStart[1], 10);
+            continue;
+        }
+        if (segment.match(/<\/\s*h[1-6]\s*>/i)) {
+            currentHeadingLevel = undefined;
+            result.push({ text: "\n" });
+            continue;
+        }
+        // --- Links: extract href on open, clear on close ---
+        // Two regexes so a double-quoted href can contain ' and vice versa
+        const linkStart = segment.match(/<\s*a[^>]*href="([^"]*)"[^>]*>/i) ?? segment.match(/<\s*a[^>]*href='([^']*)'[^>]*>/i);
+        if (linkStart) {
+            const url = decodeHtmlEntities(linkStart[1]);
+            if (isSafeUrl(url)) {
+                // allow safe links only (javascript:, data:, etc. are rejected)
+                currentFormatting.link = { url };
+            }
+            continue;
+        }
+        if (segment.match(/<\/\s*a\s*>/i)) {
+            delete currentFormatting.link;
+            continue;
+        }
+    }
+    if (result.length === 0) {
+        const text = stripHtmlTags(html);
+        if (text) {
+            result.push({ text });
+        }
+    }
+    return result;
+}
+/**
+ * Converts an HTML string into Google Docs API batch requests.
+ *
+ * Pipeline: HTML → `parseHtmlContent()` → TextWithFormatting[] → four request buckets:
+ *   1. `insertText`            – insert each text segment sequentially starting at index 1
+ *   2. `updateTextStyle`       – apply bold/italic/underline/link/code formatting
+ *   3. `updateParagraphStyle`  – apply heading levels (HEADING_1–HEADING_6)
+ *   4. `createParagraphBullets`– apply bullet/numbered list presets
+ *
+ * Requests are ordered inserts-first so that character indices remain valid when
+ * style/bullet/heading requests reference them (styles are applied after all text is inserted).
+ */
+export function parseHtmlToDocRequests(htmlContent) {
+    const textWithFormatting = parseHtmlContent(htmlContent);
+    // Requests are collected into separate buckets because the Google Docs API
+    // processes them sequentially — all text must be inserted before styles can
+    // reference the resulting character indices.
+    const insertRequests = [];
+    const styleRequests = [];
+    const bulletRequests = [];
+    const paragraphStyleRequests = [];
+    // Google Docs body starts at index 1 (index 0 is the document root)
+    let currentIndex = 1;
+    for (const item of textWithFormatting) {
+        if (!item.text) {
+            continue;
+        }
+        // Track the character range this segment will occupy once inserted
+        const startIndex = currentIndex;
+        const endIndex = currentIndex + item.text.length;
+        // Always insert the raw text first
+        insertRequests.push({
+            insertText: {
+                location: { index: startIndex },
+                text: item.text,
+            },
+        });
+        // Apply character-level styles (bold, italic, etc.) to the range we just inserted
+        if (item.formatting && Object.keys(item.formatting).length > 0) {
+            styleRequests.push({
+                updateTextStyle: {
+                    range: { startIndex, endIndex },
+                    textStyle: item.formatting,
+                    fields: fieldMaskFromTextStyle(item.formatting),
+                },
+            });
+        }
+        // Apply bullet/numbered list preset — skip whitespace-only segments to avoid
+        // creating empty bullet points
+        if (item.bulletPreset && item.text.trim().length > 0) {
+            bulletRequests.push({
+                createParagraphBullets: {
+                    range: { startIndex, endIndex },
+                    bulletPreset: item.bulletPreset,
+                },
+            });
+        }
+        // Apply heading paragraph style (HEADING_1–HEADING_6)
+        if (item.headingLevel) {
+            paragraphStyleRequests.push({
+                updateParagraphStyle: {
+                    range: { startIndex, endIndex },
+                    paragraphStyle: {
+                        namedStyleType: getNamedStyleType(item.headingLevel),
+                    },
+                    fields: "namedStyleType",
+                },
+            });
+        }
+        currentIndex = endIndex;
+    }
+    // Order matters: inserts → styles → paragraph styles → bullets.
+    // Inserts must come first so character indices exist when later requests reference them.
+    return [...insertRequests, ...styleRequests, ...paragraphStyleRequests, ...bulletRequests];
+}
+/**
+ * Converts a Markdown string into Google Docs API batch requests.
+ *
+ * Two-step pipeline: Markdown → HTML (via `marked`) → Docs requests (via `parseHtmlToDocRequests`).
+ * Falls back to plain-text insertion if `marked` throws.
+ */
+export function markdownToDocRequests(markdown) {
+    let html;
+    try {
+        html = marked.parse(markdown, { async: false });
+    }
+    catch {
+        // if marked.parse() throws, fallback to plain text insertion
+        return plainTextToDocRequests(markdown);
+    }
+    return parseHtmlToDocRequests(html);
+}
+/**
+ * Resolves which content format to use, with backwards-compatible `usesHtml` fallback.
+ * Priority: explicit `contentFormat` > legacy `usesHtml: true` → "html" > default "plain".
+ */
+export function resolveContentFormat(args) {
+    if (args.contentFormat) {
+        return args.contentFormat;
+    }
+    if (args.usesHtml) {
+        return "html";
+    }
+    return "plain";
+}
+/**
+ * Dispatches content to the appropriate converter based on format.
+ * Single entry point so callers don't need to branch on format themselves.
+ */
+export function contentToDocRequests(args) {
+    const { content, format } = args;
+    if (format === "html") {
+        return parseHtmlToDocRequests(content);
+    }
+    else if (format === "markdown") {
+        return markdownToDocRequests(content);
+    }
+    return plainTextToDocRequests(content);
+}

package/dist/actions/providers/jira/commentJiraTicketWithMentions.d.ts

@@ -0,0 +1,3 @@
+import type { jiraCommentJiraTicketWithMentionsFunction } from "../../autogen/types.js";
+declare const commentJiraTicketWithMentions: jiraCommentJiraTicketWithMentionsFunction;
+export default commentJiraTicketWithMentions;

package/dist/actions/providers/jira/commentJiraTicketWithMentions.js

@@ -0,0 +1,39 @@
+import { axiosClient } from "../../util/axiosClient.js";
+import { getJiraApiConfig, getErrorMessage } from "./utils.js";
+import { extractMentions, insertMentionNodes } from "./convertMentionsInAdf.js";
+import { markdownToAdf } from "marklassian";
+const commentJiraTicketWithMentions = async ({ params, authParams, }) => {
+    const { authToken } = authParams;
+    const { issueId, comment } = params;
+    try {
+        const { apiUrl, browseUrl, isDataCenter } = getJiraApiConfig(authParams);
+        if (isDataCenter) {
+            return {
+                success: false,
+                error: "commentJiraTicketWithMentions is only supported on Jira Cloud. Use commentJiraTicket for Jira Data Center.",
+            };
+        }
+        const { sanitized, mentions } = extractMentions(comment);
+        const adf = markdownToAdf(sanitized);
+        const body = insertMentionNodes(adf, mentions);
+        const response = await axiosClient.post(`${apiUrl}/issue/${issueId}/comment`, { body }, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+        });
+        return {
+            success: true,
+            commentUrl: `${browseUrl}/browse/${issueId}?focusedCommentId=${response.data.id}`,
+        };
+    }
+    catch (error) {
+        console.error("Error commenting on Jira ticket with mentions: ", error);
+        return {
+            success: false,
+            error: getErrorMessage(error),
+        };
+    }
+};
+export default commentJiraTicketWithMentions;

package/dist/actions/providers/jira/convertMentionsInAdf.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Extracts [~accountid:XXXXX] patterns from raw text and replaces them with
+ * safe placeholders that won't be mangled by markdown parsers.
+ *
+ * Use with {@link insertMentionNodes} after markdown-to-ADF conversion.
+ */
+export declare function extractMentions(text: string): {
+    sanitized: string;
+    mentions: string[];
+};
+/**
+ * Walks an ADF tree and replaces placeholder tokens (produced by
+ * {@link extractMentions}) with proper ADF mention nodes.
+ */
+export declare function insertMentionNodes(adf: unknown, mentions: string[]): unknown;
+/**
+ * Walks an ADF tree and converts raw [~accountid:XXXXX] text patterns into
+ * ADF mention nodes. Works reliably for single mentions per paragraph; for
+ * multiple mentions use extractMentions + insertMentionNodes instead.
+ */
+export declare function convertMentionsInAdf(adf: unknown): unknown;