@crypto512/jicon-mcp 2.2.1 → 2.3.19

package/dist/utils/sandbox/formatters.js

@@ -0,0 +1,690 @@
+/**
+ * Sandbox Formatters
+ *
+ * XHTML table and list generation functions for the sandbox.
+ * These are injected as JavaScript code that gets evaluated in the sandbox.
+ *
+ * The formatters support:
+ * - Column configuration (field, header, width, alignment)
+ * - Auto-linking (Jira, Confluence, custom URL templates)
+ * - Conditional styling (color, bold, icons based on conditions)
+ * - Row numbering
+ * - Template-based lists with {{field}} placeholders
+ */
+/**
+ * JavaScript code for formatter functions.
+ * This gets evaluated in the sandbox to define toTable() and toList().
+ *
+ * Note: JIRA_URL and CONFLUENCE_URL are injected separately as context variables.
+ */
+export const FORMATTER_FUNCTIONS_JS = `
+// ============================================================================
+// XML Escaping
+// ============================================================================
+
+/**
+ * Escape XML special characters
+ */
+function escapeXml(str) {
+  if (str == null) return '';
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+// ============================================================================
+// Conditional Formatting
+// ============================================================================
+
+/**
+ * Evaluate a single filter condition
+ */
+function evaluateCondition(item, condition) {
+  const value = get(item, condition.field);
+  const compareValue = condition.value;
+
+  let matches = false;
+
+  switch (condition.operator) {
+    case 'eq':
+      matches = value == compareValue;
+      break;
+    case 'ne':
+      matches = value != compareValue;
+      break;
+    case 'gt':
+      matches = value > compareValue;
+      break;
+    case 'lt':
+      matches = value < compareValue;
+      break;
+    case 'gte':
+      matches = value >= compareValue;
+      break;
+    case 'lte':
+      matches = value <= compareValue;
+      break;
+    case 'contains':
+      matches = String(value ?? '').toLowerCase().includes(String(compareValue ?? '').toLowerCase());
+      break;
+    case 'startsWith':
+      matches = String(value ?? '').toLowerCase().startsWith(String(compareValue ?? '').toLowerCase());
+      break;
+    case 'endsWith':
+      matches = String(value ?? '').toLowerCase().endsWith(String(compareValue ?? '').toLowerCase());
+      break;
+    case 'in':
+      matches = Array.isArray(compareValue) && compareValue.includes(value);
+      break;
+    case 'notIn':
+      matches = !Array.isArray(compareValue) || !compareValue.includes(value);
+      break;
+    case 'exists':
+      matches = value !== null && value !== undefined;
+      break;
+    case 'notExists':
+      matches = value === null || value === undefined;
+      break;
+    case 'regex':
+      try {
+        matches = new RegExp(compareValue).test(String(value ?? ''));
+      } catch (e) {
+        matches = false;
+      }
+      break;
+    case 'empty':
+      matches = value == null || value === '' || (Array.isArray(value) && value.length === 0);
+      break;
+    case 'notEmpty':
+      matches = value != null && value !== '' && (!Array.isArray(value) || value.length > 0);
+      break;
+    default:
+      matches = false;
+  }
+
+  // Handle OR conditions
+  if (!matches && condition.or && Array.isArray(condition.or)) {
+    for (const orCondition of condition.or) {
+      if (evaluateCondition(item, orCondition)) {
+        matches = true;
+        break;
+      }
+    }
+  }
+
+  return matches;
+}
+
+/**
+ * Evaluate format rules and return styles
+ */
+function evaluateFormats(item, formats) {
+  const fieldStyles = {};
+  let rowStyle = {};
+
+  if (!formats || !Array.isArray(formats)) {
+    return { fieldStyles, rowStyle };
+  }
+
+  for (const format of formats) {
+    if (evaluateCondition(item, format.condition)) {
+      if (format.fields && format.fields.length > 0) {
+        // Apply to specific fields
+        for (const field of format.fields) {
+          fieldStyles[field] = { ...(fieldStyles[field] || {}), ...format.style };
+        }
+      } else {
+        // Apply to entire row
+        rowStyle = { ...rowStyle, ...format.style };
+      }
+    }
+  }
+
+  return { fieldStyles, rowStyle };
+}
+
+/**
+ * Convert style config to inline CSS
+ */
+function styleToInlineCss(style) {
+  if (!style) return '';
+  const parts = [];
+  if (style.color) parts.push('color: ' + style.color);
+  if (style.backgroundColor) parts.push('background-color: ' + style.backgroundColor);
+  if (style.bold) parts.push('font-weight: bold');
+  if (style.italic) parts.push('font-style: italic');
+  return parts.join('; ');
+}
+
+/**
+ * Apply text decorations (prefix, suffix, icon)
+ */
+function applyTextDecorations(value, style) {
+  if (!style) return value;
+  let result = value;
+  if (style.icon) result = style.icon + ' ' + result;
+  if (style.prefix) result = style.prefix + result;
+  if (style.suffix) result = result + style.suffix;
+  return result;
+}
+
+/**
+ * Format cell value with styling
+ */
+function formatCellXhtml(value, style) {
+  // Convert value to string
+  let strValue;
+  if (value == null) {
+    strValue = '';
+  } else if (Array.isArray(value)) {
+    strValue = value.join(', ');
+  } else if (typeof value === 'object') {
+    strValue = JSON.stringify(value);
+  } else {
+    strValue = String(value);
+  }
+
+  // Escape HTML
+  strValue = escapeXml(strValue);
+
+  // Apply decorations
+  if (style) {
+    strValue = applyTextDecorations(strValue, style);
+  }
+
+  // Wrap in styled span if needed
+  if (style) {
+    const inlineCss = styleToInlineCss(style);
+    if (inlineCss || style.cssClass) {
+      const attrs = [];
+      if (style.cssClass) attrs.push('class="' + escapeXml(style.cssClass) + '"');
+      if (inlineCss) attrs.push('style="' + escapeXml(inlineCss) + '"');
+      return '<span ' + attrs.join(' ') + '>' + strValue + '</span>';
+    }
+  }
+
+  return strValue;
+}
+
+/**
+ * Get effective style for a field (merge row and field styles)
+ */
+function getEffectiveStyle(fieldStyles, rowStyle, field) {
+  const fieldStyle = fieldStyles[field];
+  if (!fieldStyle && !rowStyle) return null;
+  if (!fieldStyle) return rowStyle;
+  if (!rowStyle) return fieldStyle;
+  return { ...rowStyle, ...fieldStyle };
+}
+
+// ============================================================================
+// Link Generation
+// ============================================================================
+
+/**
+ * Generate link URL based on config
+ */
+function generateLinkUrl(value, item, link) {
+  const strValue = value == null ? '' : String(value);
+  if (!strValue) return null;
+
+  switch (link.type) {
+    case 'jira':
+      if (typeof JIRA_URL !== 'undefined' && JIRA_URL) {
+        return JIRA_URL + '/browse/' + strValue;
+      }
+      return null;
+    case 'confluence':
+      if (typeof CONFLUENCE_URL !== 'undefined' && CONFLUENCE_URL) {
+        return CONFLUENCE_URL + '/pages/viewpage.action?pageId=' + strValue;
+      }
+      return null;
+    case 'tempo':
+      return null;
+    case 'custom':
+      if (link.template) {
+        let url = link.template;
+        const placeholders = url.match(/\\{\\{(\\w+(?:\\.\\w+)*)\\}\\}/g) || [];
+        for (const placeholder of placeholders) {
+          const fieldPath = placeholder.slice(2, -2);
+          const fieldValue = fieldPath === 'value' ? strValue : get(item, fieldPath);
+          url = url.replace(placeholder, encodeURIComponent(String(fieldValue ?? '')));
+        }
+        return url;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+
+// ============================================================================
+// toTable() - Confluence Table Generator
+// ============================================================================
+
+/**
+ * Generate XHTML table from array of objects
+ *
+ * @param {Array} array - Array of objects to display
+ * @param {Object} config - Table configuration
+ * @param {string} [config.title] - Optional h2 title above table
+ * @param {Array} config.columns - Column definitions
+ * @param {string} config.columns[].field - Field path (dot notation supported)
+ * @param {string} config.columns[].header - Column header text
+ * @param {Object} [config.columns[].link] - Link configuration
+ * @param {string} [config.columns[].width] - CSS width
+ * @param {string} [config.columns[].align] - Text alignment
+ * @param {boolean} [config.showRowNumbers] - Add row number column
+ * @param {string} [config.tableClass] - CSS class for table
+ * @param {Array} [config.format] - Conditional formatting rules
+ * @returns {Object} { __xhtml: true, content: string }
+ */
+function toTable(array, config) {
+  if (!Array.isArray(array)) {
+    throw new Error('toTable: first argument must be an array');
+  }
+  if (!config || !config.columns || !Array.isArray(config.columns)) {
+    throw new Error('toTable: config.columns is required and must be an array');
+  }
+
+  const lines = [];
+
+  // Add title if present
+  if (config.title) {
+    lines.push('<h2>' + escapeXml(config.title) + '</h2>');
+  }
+
+  // Table attributes
+  const tableAttrs = config.tableClass ? ' class="' + escapeXml(config.tableClass) + '"' : '';
+
+  // Table start
+  lines.push('<table' + tableAttrs + '>');
+
+  // Header row
+  lines.push('<thead>');
+  const headerCells = [];
+  if (config.showRowNumbers) {
+    headerCells.push('<th style="text-align: right; width: 30px">#</th>');
+  }
+  for (const col of config.columns) {
+    const attrs = [];
+    if (col.align && col.align !== 'left') {
+      attrs.push('style="text-align: ' + col.align + '"');
+    }
+    if (col.width) {
+      const existingStyle = attrs.find(a => a.startsWith('style='));
+      if (existingStyle) {
+        const idx = attrs.indexOf(existingStyle);
+        attrs[idx] = existingStyle.replace('style="', 'style="width: ' + col.width + '; ');
+      } else {
+        attrs.push('style="width: ' + col.width + '"');
+      }
+    }
+    const attrStr = attrs.length > 0 ? ' ' + attrs.join(' ') : '';
+    headerCells.push('<th' + attrStr + '>' + escapeXml(col.header) + '</th>');
+  }
+  lines.push('<tr>' + headerCells.join('') + '</tr>');
+  lines.push('</thead>');
+
+  // Body rows
+  lines.push('<tbody>');
+  array.forEach(function(item, index) {
+    const { fieldStyles, rowStyle } = evaluateFormats(item, config.format);
+    const cells = [];
+
+    // Row number
+    if (config.showRowNumbers) {
+      cells.push('<td style="text-align: right; width: 30px">' + (index + 1) + '</td>');
+    }
+
+    // Data cells
+    for (const col of config.columns) {
+      const value = get(item, col.field);
+      const style = getEffectiveStyle(fieldStyles, rowStyle, col.field);
+      let content = formatCellXhtml(value, style);
+
+      // Add link if configured
+      if (col.link) {
+        const url = generateLinkUrl(value, item, col.link);
+        if (url) {
+          content = '<a href="' + escapeXml(url) + '">' + content + '</a>';
+        }
+      }
+
+      // Cell attributes
+      const cellAttrs = [];
+      if (col.align && col.align !== 'left') {
+        cellAttrs.push('style="text-align: ' + col.align + '"');
+      }
+      if (col.width) {
+        const existingStyle = cellAttrs.find(a => a.startsWith('style='));
+        if (existingStyle) {
+          const idx = cellAttrs.indexOf(existingStyle);
+          cellAttrs[idx] = existingStyle.replace('style="', 'style="width: ' + col.width + '; ');
+        } else {
+          cellAttrs.push('style="width: ' + col.width + '"');
+        }
+      }
+      const cellAttrStr = cellAttrs.length > 0 ? ' ' + cellAttrs.join(' ') : '';
+      cells.push('<td' + cellAttrStr + '>' + content + '</td>');
+    }
+
+    // Row attributes
+    let rowAttrs = '';
+    if (rowStyle) {
+      const rowCss = styleToInlineCss(rowStyle);
+      if (rowCss) rowAttrs = ' style="' + escapeXml(rowCss) + '"';
+      if (rowStyle.cssClass) rowAttrs += ' class="' + escapeXml(rowStyle.cssClass) + '"';
+    }
+
+    lines.push('<tr' + rowAttrs + '>' + cells.join('') + '</tr>');
+  });
+  lines.push('</tbody>');
+
+  // Table end
+  lines.push('</table>');
+
+  // Return marked XHTML object with toString for string concatenation
+  const xhtml = lines.join('\\n');
+  return { __xhtml: true, content: xhtml, toString: function() { return xhtml; } };
+}
+
+// ============================================================================
+// toList() - Confluence List Generator
+// ============================================================================
+
+/**
+ * Generate XHTML list from array of objects
+ *
+ * @param {Array} array - Array of objects to display
+ * @param {Object} config - List configuration
+ * @param {string} [config.title] - Optional h2 title above list
+ * @param {string} config.template - Template with {{field}} placeholders
+ * @param {string} [config.style] - List style: "bullet", "numbered", "none"
+ * @param {Array} [config.format] - Conditional formatting rules
+ * @returns {Object} { __xhtml: true, content: string }
+ */
+function toList(array, config) {
+  if (!Array.isArray(array)) {
+    throw new Error('toList: first argument must be an array');
+  }
+  if (!config || typeof config.template !== 'string') {
+    throw new Error('toList: config.template is required and must be a string');
+  }
+
+  const lines = [];
+
+  // Add title if present
+  if (config.title) {
+    lines.push('<h2>' + escapeXml(config.title) + '</h2>');
+  }
+
+  // Determine list tag
+  const listStyle = config.style || 'bullet';
+  const listTag = listStyle === 'numbered' ? 'ol' : 'ul';
+  const listAttr = listStyle === 'none' ? ' style="list-style-type: none"' : '';
+
+  // List start
+  lines.push('<' + listTag + listAttr + '>');
+
+  // List items
+  for (const item of array) {
+    const { fieldStyles, rowStyle } = evaluateFormats(item, config.format);
+
+    // Process template
+    let content = config.template;
+    const placeholders = content.match(/\\{\\{(\\w+(?:\\.\\w+)*)\\}\\}/g) || [];
+    for (const placeholder of placeholders) {
+      const fieldPath = placeholder.slice(2, -2);
+      const value = get(item, fieldPath);
+      const style = getEffectiveStyle(fieldStyles, rowStyle, fieldPath);
+      const formattedValue = formatCellXhtml(value, style);
+      content = content.replace(placeholder, formattedValue);
+    }
+
+    // Item attributes
+    let liAttrs = '';
+    if (rowStyle) {
+      const css = styleToInlineCss(rowStyle);
+      if (css) liAttrs = ' style="' + escapeXml(css) + '"';
+      if (rowStyle.cssClass) liAttrs += ' class="' + escapeXml(rowStyle.cssClass) + '"';
+    }
+
+    lines.push('<li' + liAttrs + '>' + content + '</li>');
+  }
+
+  // List end
+  lines.push('</' + listTag + '>');
+
+  // Return marked XHTML object with toString for string concatenation
+  const xhtml = lines.join('\\n');
+  return { __xhtml: true, content: xhtml, toString: function() { return xhtml; } };
+}
+
+// ============================================================================
+// Markdown Formatters
+// ============================================================================
+
+/**
+ * Escape Markdown special characters in text
+ * Note: We intentionally do NOT escape [ and ] because:
+ * 1. They don't break markdown tables (only | does)
+ * 2. Some frontends interpret \\[...\\] as LaTeX math mode
+ */
+function escapeMd(str) {
+  if (str == null) return '';
+  return String(str)
+    .replace(/\\\\/g, '\\\\\\\\')
+    .replace(/\\|/g, '\\\\|')
+    .replace(/\\n/g, ' ');
+}
+
+/**
+ * Format cell value for Markdown with optional styling
+ */
+function formatCellMarkdown(value, style) {
+  // Convert value to string
+  let strValue;
+  if (value == null) {
+    strValue = '';
+  } else if (Array.isArray(value)) {
+    strValue = value.join(', ');
+  } else if (typeof value === 'object') {
+    strValue = JSON.stringify(value);
+  } else {
+    strValue = String(value);
+  }
+
+  // Escape markdown special chars
+  strValue = escapeMd(strValue);
+
+  // Apply decorations
+  if (style) {
+    strValue = applyTextDecorations(strValue, style);
+
+    // Apply markdown formatting
+    if (style.bold) {
+      strValue = '**' + strValue + '**';
+    }
+    if (style.italic) {
+      strValue = '_' + strValue + '_';
+    }
+  }
+
+  return strValue;
+}
+
+/**
+ * Generate Markdown link
+ */
+function generateMarkdownLink(value, item, link) {
+  const url = generateLinkUrl(value, item, link);
+  if (!url) return null;
+  return { url, text: value == null ? '' : String(value) };
+}
+
+/**
+ * Generate Markdown table from array of objects
+ *
+ * @param {Array} array - Array of objects to display
+ * @param {Object} config - Table configuration
+ * @param {string} [config.title] - Optional title above table
+ * @param {Array} config.columns - Column definitions
+ * @param {string} config.columns[].field - Field path (dot notation supported)
+ * @param {string} config.columns[].header - Column header text
+ * @param {Object} [config.columns[].link] - Link configuration
+ * @param {string} [config.columns[].align] - Text alignment (left, center, right)
+ * @param {boolean} [config.showRowNumbers] - Add row number column
+ * @param {Array} [config.format] - Conditional formatting rules
+ * @returns {Object} { __markdown: true, content: string }
+ */
+function toMarkdownTable(array, config) {
+  if (!Array.isArray(array)) {
+    throw new Error('toMarkdownTable: first argument must be an array');
+  }
+  if (!config || !config.columns || !Array.isArray(config.columns)) {
+    throw new Error('toMarkdownTable: config.columns is required and must be an array');
+  }
+
+  const lines = [];
+
+  // Add title if present
+  if (config.title) {
+    lines.push('## ' + config.title);
+    lines.push('');
+  }
+
+  // Build header row
+  const headers = [];
+  const separators = [];
+
+  if (config.showRowNumbers) {
+    headers.push('#');
+    separators.push('--:'); // Right-aligned for numbers
+  }
+
+  for (const col of config.columns) {
+    headers.push(escapeMd(col.header));
+    // Alignment separator
+    if (col.align === 'center') {
+      separators.push(':--:');
+    } else if (col.align === 'right') {
+      separators.push('--:');
+    } else {
+      separators.push('---');
+    }
+  }
+
+  lines.push('| ' + headers.join(' | ') + ' |');
+  lines.push('| ' + separators.join(' | ') + ' |');
+
+  // Body rows
+  array.forEach(function(item, index) {
+    const { fieldStyles, rowStyle } = evaluateFormats(item, config.format);
+    const cells = [];
+
+    // Row number
+    if (config.showRowNumbers) {
+      cells.push(String(index + 1));
+    }
+
+    // Data cells
+    for (const col of config.columns) {
+      const value = get(item, col.field);
+      const style = getEffectiveStyle(fieldStyles, rowStyle, col.field);
+      let content = formatCellMarkdown(value, style);
+
+      // Add link if configured
+      if (col.link) {
+        const linkInfo = generateMarkdownLink(value, item, col.link);
+        if (linkInfo && linkInfo.url) {
+          content = '[' + escapeMd(linkInfo.text) + '](' + linkInfo.url + ')';
+        }
+      }
+
+      cells.push(content);
+    }
+
+    lines.push('| ' + cells.join(' | ') + ' |');
+  });
+
+  // Return marked Markdown object with toString for string concatenation
+  const md = lines.join('\\n');
+  return { __markdown: true, content: md, toString: function() { return md; } };
+}
+
+/**
+ * Generate Markdown list from array of objects
+ *
+ * @param {Array} array - Array of objects to display
+ * @param {Object} config - List configuration
+ * @param {string} [config.title] - Optional title above list
+ * @param {string} config.template - Template with {{field}} placeholders
+ * @param {string} [config.style] - List style: "bullet", "numbered", "task"
+ * @param {Array} [config.format] - Conditional formatting rules
+ * @returns {Object} { __markdown: true, content: string }
+ */
+function toMarkdownList(array, config) {
+  if (!Array.isArray(array)) {
+    throw new Error('toMarkdownList: first argument must be an array');
+  }
+  if (!config || typeof config.template !== 'string') {
+    throw new Error('toMarkdownList: config.template is required and must be a string');
+  }
+
+  const lines = [];
+
+  // Add title if present
+  if (config.title) {
+    lines.push('## ' + config.title);
+    lines.push('');
+  }
+
+  // Determine list prefix
+  const listStyle = config.style || 'bullet';
+  let counter = 1;
+
+  // List items
+  for (const item of array) {
+    const { fieldStyles, rowStyle } = evaluateFormats(item, config.format);
+
+    // Process template
+    let content = config.template;
+    const placeholders = content.match(/\\{\\{(\\w+(?:\\.\\w+)*)\\}\\}/g) || [];
+    for (const placeholder of placeholders) {
+      const fieldPath = placeholder.slice(2, -2);
+      const value = get(item, fieldPath);
+      const style = getEffectiveStyle(fieldStyles, rowStyle, fieldPath);
+      const formattedValue = formatCellMarkdown(value, style);
+      content = content.replace(placeholder, formattedValue);
+    }
+
+    // Format list item
+    let prefix;
+    if (listStyle === 'numbered') {
+      prefix = counter + '. ';
+      counter++;
+    } else if (listStyle === 'task') {
+      prefix = '- [ ] ';
+    } else {
+      prefix = '- ';
+    }
+
+    lines.push(prefix + content);
+  }
+
+  // Return marked Markdown object with toString for string concatenation
+  const md = lines.join('\\n');
+  return { __markdown: true, content: md, toString: function() { return md; } };
+}
+`;
+/**
+ * Get the JavaScript code for formatter functions
+ */
+export function getFormatterFunctionsCode() {
+    return FORMATTER_FUNCTIONS_JS;
+}
+//# sourceMappingURL=formatters.js.map

package/dist/utils/sandbox/formatters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.js","sourceRoot":"","sources":["../../../src/utils/sandbox/formatters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAupBrC,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,yBAAyB;IACvC,OAAO,sBAAsB,CAAC;AAChC,CAAC"}