@neosamon/jira-mcp-server 0.2.0 → 0.2.1

package/build/index.js

@@ -105,7 +105,254 @@ async function addComment(config, issueKey, body) {
         body: JSON.stringify({ body }),
     });
 }
-// ==================== 输出格式化函数 ====================
+/**
+ * 从对象中按嵌套路径提取值
+ * 支持点分隔的路径字符串，如 "inwardIssue.key"
+ * @param obj - 要提取的对象
+ * @param path - 路径数组（如 ["inwardIssue", "key"]）或点分隔字符串
+ * @returns 提取的值，如果路径无效则返回 null
+ */
+function extractByPath(obj, path) {
+    if (obj == null || typeof obj !== 'object') {
+        return null;
+    }
+    const parts = Array.isArray(path) ? path : path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object') {
+            return null;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * 从对象中按规则提取值
+ * 支持自定义字段顺序和格式化
+ * @param obj - 要提取的对象
+ * @param rule - 提取规则
+ * @returns 格式化后的字符串，如果无法提取则返回 null
+ */
+function extractByRule(obj, rule) {
+    // 检查所有必需字段
+    for (const field of rule.fields) {
+        if (field.required) {
+            const value = extractByPath(obj, field.path);
+            if (value == null) {
+                return null; // 必需字段不存在，规则匹配失败
+            }
+        }
+    }
+    // 收集所有字段值（按顺序）
+    const parts = [];
+    for (let i = 0; i < rule.fields.length; i++) {
+        const field = rule.fields[i];
+        const value = extractByPath(obj, field.path);
+        // 跳过不存在的可选字段
+        if (value == null) {
+            continue;
+        }
+        // 空值处理
+        if (value === '') {
+            continue;
+        }
+        // 数字转字符串
+        let part = typeof value === 'string' ? value : String(value);
+        // 应用长度限制
+        if (field.maxLength && part.length > field.maxLength) {
+            part = part.substring(0, field.maxLength) + '...';
+        }
+        // 添加前缀
+        if (field.prefix) {
+            part = field.prefix + part;
+        }
+        // 添加后缀
+        if (field.suffix) {
+            part = part + field.suffix;
+        }
+        // 添加分隔符（连接到下一个字段）
+        if (field.separator && i < rule.fields.length - 1) {
+            // 检查下一个字段是否存在
+            const nextField = rule.fields[i + 1];
+            const nextValue = extractByPath(obj, nextField.path);
+            if (nextValue != null && nextValue !== '') {
+                part = part + field.separator;
+            }
+        }
+        parts.push(part);
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    // 组合所有部分
+    let result = parts.join('');
+    // 添加整体前缀后缀
+    if (rule.prefix) {
+        result = rule.prefix + result;
+    }
+    if (rule.suffix) {
+        result = result + rule.suffix;
+    }
+    return result;
+}
+/**
+ * 提取规则配置
+ * 按优先级顺序尝试提取，第一个成功的规则被使用
+ */
+const extractionRules = [
+    // ===== 第一优先级：简单字段 =====
+    {
+        fields: [{ path: 'name', required: true }]
+    },
+    {
+        fields: [{ path: 'value', required: true }]
+    },
+    {
+        fields: [{ path: 'content', required: true }]
+    },
+    {
+        fields: [{ path: 'body', required: true }]
+    },
+    {
+        fields: [{ path: 'summary', required: true }]
+    },
+    {
+        fields: [{ path: 'title', required: true }]
+    },
+    {
+        fields: [{ path: 'key', required: true }]
+    },
+    // ===== 第二优先级：组合字段 - issuelinks (inward + outward + summary) =====
+    {
+        fields: [
+            { path: 'inwardIssue.key', required: true, prefix: '→ ', separator: ' - ' },
+            { path: 'inwardIssue.fields.summary', required: false, separator: ' ', maxLength: 50 },
+            { path: ['type', 'name'], required: false, prefix: ' [', suffix: ']' }
+        ]
+    },
+    // ===== 第三优先级：组合字段 - issuelinks (outward + summary) =====
+    {
+        fields: [
+            { path: 'outwardIssue.key', required: true, prefix: '← ', separator: ' - ' },
+            { path: 'outwardIssue.fields.summary', required: false, separator: ' ', maxLength: 50 },
+            { path: ['type', 'name'], required: false, prefix: ' [', suffix: ']' }
+        ]
+    },
+    // ===== 第四优先级：组合字段 - issuelinks (仅 inward) =====
+    {
+        fields: [
+            { path: 'inwardIssue.key', required: true, prefix: '→ ' },
+            { path: ['type', 'name'], required: false, prefix: ' [', suffix: ']' }
+        ]
+    },
+    // ===== 第五优先级：组合字段 - issuelinks (仅 outward) =====
+    {
+        fields: [
+            { path: 'outwardIssue.key', required: true, prefix: '← ' },
+            { path: ['type', 'name'], required: false, prefix: ' [', suffix: ']' }
+        ]
+    },
+    // ===== 第六优先级：组合字段简化版 =====
+    {
+        fields: [
+            { path: 'key', required: true },
+            { path: 'fields.summary', required: false, separator: ' - ', maxLength: 30 }
+        ]
+    },
+    // ===== 第七优先级：组合字段 - 仅 type =====
+    {
+        fields: [
+            { path: ['type', 'name'], required: true, prefix: ' [', suffix: ']' }
+        ]
+    },
+    // ===== 第八优先级：附件信息 =====
+    {
+        fields: [
+            { path: 'filename', required: false },
+            { path: 'mimeType', required: false, prefix: ' [', suffix: ']' },
+            { path: 'size', required: false, prefix: '(', suffix: ' bytes)' }
+        ]
+    },
+];
+/**
+ * 从对象中按优先级提取可显示的字符串值
+ * 支持简单模式和组合模式
+ * @param obj - 要提取的对象
+ * @returns 提取的字符串值，如果找不到则返回 null
+ */
+function extractPropertyValue(obj) {
+    for (const rule of extractionRules) {
+        const result = extractByRule(obj, rule);
+        if (result !== null) {
+            return result;
+        }
+    }
+    return null;
+}
+/**
+ * 格式化数组项为字符串，使用组合长度限制策略
+ * @param items - 数组项
+ * @param extractor - 从项中提取字符串的函数
+ * @param maxLength - 最大字符长度（默认 80）
+ * @returns 格式化后的字符串
+ */
+function formatArrayItems(items, extractor, maxLength = 80) {
+    // 空数组
+    if (items.length === 0) {
+        return "[]";
+    }
+    const parts = [];
+    let currentLength = 0;
+    const minItemsToShow = Math.min(2, items.length); // 至少显示 2 个元素（如果有的话）
+    for (let i = 0; i < items.length; i++) {
+        const extracted = extractor(items[i], i);
+        // 如果提取失败，停止处理
+        if (extracted === null) {
+            break;
+        }
+        const separator = parts.length > 0 ? ", " : "";
+        const newLength = currentLength + separator.length + extracted.length;
+        // 组合策略：确保至少显示 minItemsToShow 个元素，但不超过 maxLength
+        if (newLength > maxLength && parts.length >= minItemsToShow) {
+            // 超过限制且已显示足够元素，添加省略标记和总数
+            return `${parts.join(", ")}... (${items.length} total)`;
+        }
+        parts.push(extracted);
+        currentLength = newLength;
+    }
+    return parts.join(", ");
+}
+/**
+ * 尝试对单个对象应用规则列表
+ * @param obj - 要提取的对象
+ * @returns 格式化后的字符串，如果无法提取则返回 null
+ */
+function extractByRules(obj) {
+    for (const rule of extractionRules) {
+        const result = extractByRule(obj, rule);
+        if (result !== null) {
+            return result;
+        }
+    }
+    return null;
+}
+/**
+ * 格式化普通值（非对象）为字符串
+ * @param value - 值
+ * @returns 字符串表示
+ */
+function formatPrimitiveValue(value) {
+    if (value === null || value === undefined) {
+        return "(null)";
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return "(unknown)";
+}
 /**
  * 格式化字段值用于显示
  * 根据值的类型采用不同的展示策略
@@ -122,8 +369,36 @@ function formatFieldValue(value) {
         }
         return `${value.substring(0, 50)}...`;
     }
-    // 数组类型
+    // 数组类型 - 智能展开数组内容
     if (Array.isArray(value)) {
+        // 空数组
+        if (value.length === 0) {
+            return "[]";
+        }
+        // 检查数组元素类型
+        const hasObjects = value.some(item => typeof item === 'object' && item !== null);
+        const hasPrimitives = value.some(item => typeof item !== 'object');
+        // 纯普通类型数组 - 转字符串连接
+        if (!hasObjects) {
+            return formatArrayItems(value, (item) => formatPrimitiveValue(item));
+        }
+        // 对象数组 - 逐项规则匹配
+        if (!hasPrimitives) {
+            return formatArrayItems(value, (item) => extractByRules(item));
+        }
+        // 混合类型数组 - 分别处理
+        if (hasObjects && hasPrimitives) {
+            return formatArrayItems(value, (item) => {
+                if (typeof item === 'object' && item !== null) {
+                    const result = extractByRules(item);
+                    return result !== null ? result : `[Object]`;
+                }
+                else {
+                    return formatPrimitiveValue(item);
+                }
+            });
+        }
+        // 其他情况 - 回退到摘要
         return `[Array] (${value.length} items)`;
     }
     // 对象类型

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neosamon/jira-mcp-server",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Jira MCP Server - Model Context Protocol server for Jira integration",
   "type": "module",
   "main": "build/index.js",