@maxenlin/mcp-zentao-11-3 1.0.0-patch.1

package/dist/types.d.ts

@@ -0,0 +1,122 @@
+export interface Task {
+    id: number;
+    name: string;
+    status: string;
+    pri: number;
+    deadline?: string;
+    desc?: string;
+    story?: number | string;
+    product?: number | string;
+}
+export interface Bug {
+    id: number;
+    title: string;
+    status: string;
+    severity: number;
+    steps?: string;
+    openedDate?: string;
+    story?: number | string;
+    product?: number | string;
+    productName?: string;
+}
+export interface Product {
+    id: number;
+    name: string;
+    code: string;
+    status: string;
+    desc: string;
+}
+export interface Story {
+    id: number;
+    title: string;
+    status: string;
+    pri: number;
+    stage?: string;
+    estimate?: number;
+    openedBy?: string;
+    openedDate?: string;
+    assignedTo?: string;
+    spec?: string;
+    module?: string | number;
+    moduleName?: string;
+    product?: string | number;
+    productName?: string;
+}
+export interface TaskUpdate {
+    consumed?: number;
+    left?: number;
+    status?: TaskStatus;
+    finishedDate?: string;
+    comment?: string;
+}
+export interface BugResolution {
+    resolution: 'fixed' | 'notrepro' | 'duplicate' | 'bydesign' | 'willnotfix' | 'tostory' | 'external';
+    resolvedBuild?: string;
+    duplicateBug?: number;
+    comment?: string;
+}
+export interface TestCase {
+    id: number;
+    product?: number;
+    productName?: string;
+    module?: number;
+    moduleName?: string;
+    story?: number;
+    title: string;
+    type: string;
+    pri: number;
+    status: string;
+    precondition?: string;
+    steps?: string;
+    openedBy?: string;
+    openedDate?: string;
+    lastEditedBy?: string;
+    lastEditedDate?: string;
+}
+export interface TestResult {
+    id: number;
+    run: number;
+    case: number;
+    caseTitle?: string;
+    version: number;
+    status: string;
+    lastRunner?: string;
+    lastRunDate?: string;
+    lastRunResult?: string;
+}
+export interface TestTask {
+    id: number;
+    name: string;
+    product: number;
+    productName?: string;
+    project?: number;
+    execution?: number;
+    build?: string;
+    owner?: string;
+    status: string;
+    begin?: string;
+    end?: string;
+    desc?: string;
+}
+export interface CreateTestCaseRequest {
+    product: number;
+    module?: number;
+    story?: number;
+    title: string;
+    type?: string;
+    pri?: number;
+    precondition?: string;
+    steps?: string;
+    status?: string;
+}
+export interface TestRunRequest {
+    caseId: number;
+    version?: number;
+    result: 'pass' | 'fail' | 'blocked' | 'skipped';
+    steps?: string;
+    comment?: string;
+}
+export type TaskStatus = 'wait' | 'doing' | 'done' | 'all';
+export type BugStatus = 'active' | 'resolved' | 'closed' | 'all';
+export type StoryStatus = 'draft' | 'active' | 'closed' | 'changed' | 'all';
+export type TestCaseStatus = 'normal' | 'blocked' | 'investigate' | 'all';

package/dist/types.js

@@ -0,0 +1,2 @@
+// 只保留 legacy 11.3 需要的类型定义
+export {};

package/dist/utils/analyzer.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 智能分析工具
+ * 用于分析需求复杂度、Bug 优先级等
+ */
+import { Story, Bug, Task } from '../types.js';
+export interface ComplexityAnalysis {
+    score: number;
+    factors: {
+        descriptionLength: number;
+        hasImages: boolean;
+        relatedBugsCount: number;
+        testCasesCount: number;
+    };
+    estimatedHours?: number;
+    prioritySuggestion: 'low' | 'medium' | 'high';
+}
+export interface PriorityAnalysis {
+    score: number;
+    factors: {
+        severity: number;
+        hasRelatedStory: boolean;
+        status: string;
+    };
+    suggestion: 'low' | 'medium' | 'high' | 'urgent';
+}
+/**
+ * 分析需求复杂度
+ */
+export declare function analyzeStoryComplexity(story: Story, relatedBugsCount?: number, testCasesCount?: number): ComplexityAnalysis;
+/**
+ * 分析 Bug 优先级
+ */
+export declare function analyzeBugPriority(bug: Bug, hasRelatedStory?: boolean): PriorityAnalysis;
+/**
+ * 分析任务工作量
+ */
+export declare function analyzeTaskWorkload(task: Task): {
+    estimatedHours: number;
+    difficulty: 'easy' | 'medium' | 'hard';
+    factors: {
+        descriptionLength: number;
+        priority: number;
+        hasDeadline: boolean;
+    };
+};

package/dist/utils/analyzer.js

@@ -0,0 +1,183 @@
+/**
+ * 智能分析工具
+ * 用于分析需求复杂度、Bug 优先级等
+ */
+/**
+ * 分析需求复杂度
+ */
+export function analyzeStoryComplexity(story, relatedBugsCount = 0, testCasesCount = 0) {
+    let score = 0;
+    const factors = {
+        descriptionLength: 0,
+        hasImages: false,
+        relatedBugsCount,
+        testCasesCount
+    };
+    // 描述长度分析
+    if (story.spec) {
+        factors.descriptionLength = story.spec.length;
+        if (story.spec.length > 1000) {
+            score += 3;
+        }
+        else if (story.spec.length > 500) {
+            score += 2;
+        }
+        else if (story.spec.length > 200) {
+            score += 1;
+        }
+    }
+    // 图片分析（有图片通常意味着更复杂的需求）
+    if (story.spec && story.spec.includes('<img')) {
+        factors.hasImages = true;
+        score += 1;
+    }
+    // 关联 Bug 数量（Bug 多可能意味着需求复杂）
+    factors.relatedBugsCount = relatedBugsCount;
+    if (relatedBugsCount > 5) {
+        score += 2;
+    }
+    else if (relatedBugsCount > 2) {
+        score += 1;
+    }
+    // 测试用例数量（测试用例多可能意味着功能复杂）
+    factors.testCasesCount = testCasesCount;
+    if (testCasesCount > 10) {
+        score += 2;
+    }
+    else if (testCasesCount > 5) {
+        score += 1;
+    }
+    // 优先级影响
+    if (story.pri === 1) {
+        score += 1; // 高优先级需求可能更复杂
+    }
+    // 确保分数在 1-10 范围内
+    score = Math.max(1, Math.min(10, score));
+    // 估算工时（基于复杂度）
+    let estimatedHours;
+    if (score <= 3) {
+        estimatedHours = 2; // 简单需求
+    }
+    else if (score <= 6) {
+        estimatedHours = 4; // 中等需求
+    }
+    else if (score <= 8) {
+        estimatedHours = 8; // 复杂需求
+    }
+    else {
+        estimatedHours = 16; // 非常复杂的需求
+    }
+    // 优先级建议
+    let prioritySuggestion;
+    if (score <= 3) {
+        prioritySuggestion = 'low';
+    }
+    else if (score <= 6) {
+        prioritySuggestion = 'medium';
+    }
+    else {
+        prioritySuggestion = 'high';
+    }
+    return {
+        score,
+        factors,
+        estimatedHours,
+        prioritySuggestion
+    };
+}
+/**
+ * 分析 Bug 优先级
+ */
+export function analyzeBugPriority(bug, hasRelatedStory = false) {
+    let score = 0;
+    const factors = {
+        severity: bug.severity || 0,
+        hasRelatedStory,
+        status: bug.status || ''
+    };
+    // 严重程度分析
+    factors.severity = bug.severity || 0;
+    if (bug.severity === 1) {
+        score += 4; // 致命 Bug
+    }
+    else if (bug.severity === 2) {
+        score += 3; // 严重 Bug
+    }
+    else if (bug.severity === 3) {
+        score += 2; // 一般 Bug
+    }
+    else {
+        score += 1; // 轻微 Bug
+    }
+    // 状态分析
+    if (bug.status === 'active') {
+        score += 2; // 激活状态的 Bug 需要优先处理
+    }
+    else if (bug.status === 'resolved') {
+        score -= 1; // 已解决的 Bug 优先级降低
+    }
+    // 关联需求分析
+    factors.hasRelatedStory = hasRelatedStory;
+    if (hasRelatedStory) {
+        score += 1; // 有关联需求的 Bug 可能需要优先处理
+    }
+    // 确保分数在 1-10 范围内
+    score = Math.max(1, Math.min(10, score));
+    // 优先级建议
+    let suggestion;
+    if (score <= 3) {
+        suggestion = 'low';
+    }
+    else if (score <= 5) {
+        suggestion = 'medium';
+    }
+    else if (score <= 7) {
+        suggestion = 'high';
+    }
+    else {
+        suggestion = 'urgent';
+    }
+    return {
+        score,
+        factors,
+        suggestion
+    };
+}
+/**
+ * 分析任务工作量
+ */
+export function analyzeTaskWorkload(task) {
+    const factors = {
+        descriptionLength: task.desc?.length || 0,
+        priority: task.pri || 0,
+        hasDeadline: !!task.deadline
+    };
+    let estimatedHours = 2; // 默认 2 小时
+    // 描述长度影响
+    if (factors.descriptionLength > 500) {
+        estimatedHours += 2;
+    }
+    else if (factors.descriptionLength > 200) {
+        estimatedHours += 1;
+    }
+    // 优先级影响（高优先级任务可能需要更多时间）
+    if (factors.priority === 1) {
+        estimatedHours += 1;
+    }
+    // 难度评估
+    let difficulty;
+    if (estimatedHours <= 2) {
+        difficulty = 'easy';
+    }
+    else if (estimatedHours <= 4) {
+        difficulty = 'medium';
+    }
+    else {
+        difficulty = 'hard';
+    }
+    return {
+        estimatedHours,
+        difficulty,
+        factors
+    };
+}

package/dist/utils/formatter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 格式化工具函数
+ * 用于将需求、Bug、任务等格式化为 Markdown 或其他格式
+ */
+import { Story, Bug, Task } from '../types.js';
+/**
+ * 格式化需求为 Markdown
+ */
+export declare function formatStoryAsMarkdown(story: Story): string;
+/**
+ * 格式化 Bug 为 Markdown
+ */
+export declare function formatBugAsMarkdown(bug: Bug): string;
+/**
+ * 格式化任务为 Markdown
+ */
+export declare function formatTaskAsMarkdown(task: Task): string;
+/**
+ * 生成需求摘要
+ */
+export declare function generateStorySummary(story: Story): string;
+/**
+ * 生成 Bug 摘要
+ */
+export declare function generateBugSummary(bug: Bug): string;

package/dist/utils/formatter.js

@@ -0,0 +1,157 @@
+/**
+ * 格式化工具函数
+ * 用于将需求、Bug、任务等格式化为 Markdown 或其他格式
+ */
+/**
+ * 格式化需求为 Markdown
+ */
+export function formatStoryAsMarkdown(story) {
+    const lines = [];
+    lines.push(`# 需求 #${story.id}: ${story.title}`);
+    lines.push('');
+    if (story.productName) {
+        lines.push(`**产品**: ${story.productName}`);
+    }
+    if (story.moduleName) {
+        lines.push(`**模块**: ${story.moduleName}`);
+    }
+    if (story.status) {
+        lines.push(`**状态**: ${story.status}`);
+    }
+    if (story.pri) {
+        lines.push(`**优先级**: ${story.pri}`);
+    }
+    if (story.stage) {
+        lines.push(`**阶段**: ${story.stage}`);
+    }
+    if (story.estimate) {
+        lines.push(`**预估工时**: ${story.estimate} 小时`);
+    }
+    if (story.assignedTo) {
+        lines.push(`**指派给**: ${story.assignedTo}`);
+    }
+    if (story.openedBy) {
+        lines.push(`**创建人**: ${story.openedBy}`);
+    }
+    if (story.openedDate) {
+        lines.push(`**创建时间**: ${story.openedDate}`);
+    }
+    lines.push('');
+    lines.push('## 需求描述');
+    lines.push('');
+    if (story.spec) {
+        lines.push(story.spec);
+    }
+    else {
+        lines.push('*暂无描述*');
+    }
+    return lines.join('\n');
+}
+/**
+ * 格式化 Bug 为 Markdown
+ */
+export function formatBugAsMarkdown(bug) {
+    const lines = [];
+    lines.push(`# Bug #${bug.id}: ${bug.title}`);
+    lines.push('');
+    if (bug.productName) {
+        lines.push(`**产品**: ${bug.productName}`);
+    }
+    if (bug.status) {
+        lines.push(`**状态**: ${bug.status}`);
+    }
+    if (bug.severity) {
+        lines.push(`**严重程度**: ${bug.severity}`);
+    }
+    if (bug.openedDate) {
+        lines.push(`**创建时间**: ${bug.openedDate}`);
+    }
+    if (bug.story) {
+        lines.push(`**关联需求**: #${bug.story}`);
+    }
+    lines.push('');
+    lines.push('## 复现步骤');
+    lines.push('');
+    if (bug.steps) {
+        lines.push(bug.steps);
+    }
+    else {
+        lines.push('*暂无复现步骤*');
+    }
+    return lines.join('\n');
+}
+/**
+ * 格式化任务为 Markdown
+ */
+export function formatTaskAsMarkdown(task) {
+    const lines = [];
+    lines.push(`# 任务 #${task.id}: ${task.name}`);
+    lines.push('');
+    lines.push(`**状态**: ${task.status}`);
+    lines.push(`**优先级**: ${task.pri}`);
+    if (task.deadline) {
+        lines.push(`**截止日期**: ${task.deadline}`);
+    }
+    if (task.story) {
+        lines.push(`**关联需求**: #${task.story}`);
+    }
+    if (task.product) {
+        lines.push(`**产品**: #${task.product}`);
+    }
+    lines.push('');
+    lines.push('## 任务描述');
+    lines.push('');
+    if (task.desc) {
+        lines.push(task.desc);
+    }
+    else {
+        lines.push('*暂无描述*');
+    }
+    return lines.join('\n');
+}
+/**
+ * 生成需求摘要
+ */
+export function generateStorySummary(story) {
+    const parts = [];
+    parts.push(`需求 #${story.id}: ${story.title}`);
+    if (story.status) {
+        parts.push(`状态: ${story.status}`);
+    }
+    if (story.pri) {
+        parts.push(`优先级: ${story.pri}`);
+    }
+    if (story.productName) {
+        parts.push(`产品: ${story.productName}`);
+    }
+    if (story.spec) {
+        const specPreview = story.spec.length > 100
+            ? story.spec.substring(0, 100) + '...'
+            : story.spec;
+        parts.push(`描述: ${specPreview}`);
+    }
+    return parts.join(' | ');
+}
+/**
+ * 生成 Bug 摘要
+ */
+export function generateBugSummary(bug) {
+    const parts = [];
+    parts.push(`Bug #${bug.id}: ${bug.title}`);
+    if (bug.status) {
+        parts.push(`状态: ${bug.status}`);
+    }
+    if (bug.severity) {
+        parts.push(`严重程度: ${bug.severity}`);
+    }
+    if (bug.productName) {
+        parts.push(`产品: ${bug.productName}`);
+    }
+    if (bug.steps) {
+        const stepsPreview = bug.steps.length > 100
+            ? bug.steps.substring(0, 100) + '...'
+            : bug.steps;
+        parts.push(`复现步骤: ${stepsPreview}`);
+    }
+    return parts.join(' | ');
+}

package/dist/utils/imageDownloader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 图片下载工具函数
+ * 统一处理 Bug 和需求的图片下载逻辑
+ */
+import { ZentaoLegacyAPI } from '../zentaoLegacyApi.js';
+export interface DownloadedImage {
+    url: string;
+    base64?: string;
+    mimeType?: string;
+    size?: number;
+    success: boolean;
+    error?: string;
+}
+/**
+ * 下载图片列表
+ * @param zentaoApi Zentao API 实例
+ * @param imageUrls 图片 URL 列表
+ * @param parallel 是否并行下载（默认 true）
+ * @returns 下载结果数组
+ */
+export declare function downloadImages(zentaoApi: ZentaoLegacyAPI, imageUrls: string[], parallel?: boolean): Promise<DownloadedImage[]>;
+/**
+ * 构建 MCP image 内容数组
+ */
+export declare function buildImageContent(downloadedImages: DownloadedImage[], entityType: 'bug' | 'story', entityId: number): any[];

package/dist/utils/imageDownloader.js

@@ -0,0 +1,104 @@
+/**
+ * 图片下载工具函数
+ * 统一处理 Bug 和需求的图片下载逻辑
+ */
+/**
+ * 检测图片 MIME 类型
+ */
+function detectMimeType(buffer) {
+    if (buffer[0] === 0xFF && buffer[1] === 0xD8) {
+        return 'image/jpeg';
+    }
+    else if (buffer[0] === 0x47 && buffer[1] === 0x49) {
+        return 'image/gif';
+    }
+    else if (buffer[0] === 0x89 && buffer[1] === 0x50) {
+        return 'image/png';
+    }
+    return 'image/png'; // 默认
+}
+/**
+ * 下载图片列表
+ * @param zentaoApi Zentao API 实例
+ * @param imageUrls 图片 URL 列表
+ * @param parallel 是否并行下载（默认 true）
+ * @returns 下载结果数组
+ */
+export async function downloadImages(zentaoApi, imageUrls, parallel = true) {
+    if (imageUrls.length === 0) {
+        return [];
+    }
+    if (parallel) {
+        // 并行下载
+        const downloadPromises = imageUrls.map(async (url) => {
+            try {
+                const imageBuffer = await zentaoApi.downloadStoryImage(url);
+                const base64Image = imageBuffer.toString('base64');
+                const mimeType = detectMimeType(imageBuffer);
+                return {
+                    url,
+                    base64: base64Image,
+                    mimeType,
+                    size: imageBuffer.length,
+                    success: true
+                };
+            }
+            catch (error) {
+                return {
+                    url,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        });
+        return Promise.all(downloadPromises);
+    }
+    else {
+        // 串行下载（兼容旧逻辑）
+        const results = [];
+        for (const url of imageUrls) {
+            try {
+                const imageBuffer = await zentaoApi.downloadStoryImage(url);
+                const base64Image = imageBuffer.toString('base64');
+                const mimeType = detectMimeType(imageBuffer);
+                results.push({
+                    url,
+                    base64: base64Image,
+                    mimeType,
+                    size: imageBuffer.length,
+                    success: true
+                });
+            }
+            catch (error) {
+                results.push({
+                    url,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        return results;
+    }
+}
+/**
+ * 构建 MCP image 内容数组
+ */
+export function buildImageContent(downloadedImages, entityType, entityId) {
+    const content = [];
+    downloadedImages.forEach((img, index) => {
+        if (img.success && img.base64) {
+            content.push({
+                type: "image",
+                data: img.base64,
+                mimeType: img.mimeType || 'image/png',
+                annotations: {
+                    audience: ["user"],
+                    priority: 0.8,
+                    title: `${entityType === 'bug' ? 'Bug' : '需求'} ${entityId} 的图片 ${index + 1}`,
+                    description: `来源: ${img.url}`
+                }
+            });
+        }
+    });
+    return content;
+}

package/dist/utils/suggestions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 操作建议工具
+ * 根据当前上下文，建议下一步操作
+ */
+import { Story, Bug, Task } from '../types.js';
+export interface NextActionSuggestion {
+    action: string;
+    description: string;
+    tool?: string;
+    toolArgs?: Record<string, any>;
+    priority: 'high' | 'medium' | 'low';
+}
+/**
+ * 根据需求上下文生成下一步建议
+ */
+export declare function suggestNextActionsForStory(story: Story, hasRelatedBugs: boolean, hasTestCases: boolean): NextActionSuggestion[];
+/**
+ * 根据 Bug 上下文生成下一步建议
+ */
+export declare function suggestNextActionsForBug(bug: Bug, hasRelatedStory: boolean, isActive: boolean): NextActionSuggestion[];
+/**
+ * 根据任务上下文生成下一步建议
+ */
+export declare function suggestNextActionsForTask(task: Task, isCompleted?: boolean): NextActionSuggestion[];
+/**
+ * 格式化建议为 Markdown
+ */
+export declare function formatSuggestionsAsMarkdown(suggestions: NextActionSuggestion[]): string;