@muzzamil-khan/redmine-agent-mcp 1.0.0 → 1.2.0

package/dist/workflows/createIssueWorkflow.js

@@ -0,0 +1,697 @@
+import axios from "axios";
+import { createIssue, getCustomFields, getProjects, getProjectVersions, } from "../services/redmine.js";
+import { applyPriorityAlias, applyTrackerAlias, configOptionsPayload, enumerationOptions, loadRedmineConfig, resolvePriority, resolveStatus, resolveTracker, } from "../services/redmineConfig.js";
+import { requireRedmineEnv } from "../config/env.js";
+import { lookupIdByName, resolveAssignedToId } from "./issueCreationHelpers.js";
+const OPTIONAL_TEXT_FIELDS = [
+    "description",
+    "assignedTo",
+    "targetVersion",
+    "parentTask",
+    "startDate",
+    "dueDate",
+    "estimatedTime",
+    "qaStatus",
+    "gitLink",
+    "gitLink1",
+    "gitLink2",
+    "expectedTime",
+    "prLink",
+    "storyPoints",
+];
+function todayMmDdYyyy() {
+    const now = new Date();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const year = String(now.getFullYear());
+    return `${month}/${day}/${year}`;
+}
+function defaultTrackerName(config) {
+    return (resolveTracker("User Story", config)?.name ??
+        resolveTracker("story", config)?.name ??
+        config.trackers[0]?.name ??
+        "User Story");
+}
+function defaultStatusName(config) {
+    return (resolveStatus("New", config)?.name ??
+        config.statuses[0]?.name ??
+        "New");
+}
+function defaultPriorityName(config) {
+    return (resolvePriority("Normal", config)?.name ??
+        config.priorities[0]?.name ??
+        "Normal");
+}
+function buildDraft(input, config) {
+    const trackerRaw = input.tracker?.trim();
+    const statusRaw = input.status?.trim();
+    const priorityRaw = input.priority?.trim();
+    return {
+        project: input.project?.trim() || "",
+        tracker: trackerRaw
+            ? (resolveTracker(trackerRaw, config)?.name ??
+                applyTrackerAlias(trackerRaw))
+            : defaultTrackerName(config),
+        status: statusRaw
+            ? (resolveStatus(statusRaw, config)?.name ?? statusRaw)
+            : defaultStatusName(config),
+        priority: priorityRaw
+            ? (resolvePriority(priorityRaw, config)?.name ??
+                applyPriorityAlias(priorityRaw))
+            : defaultPriorityName(config),
+        subject: "",
+        description: "",
+        assignedTo: "",
+        targetVersion: "",
+        parentTask: "",
+        startDate: todayMmDdYyyy(),
+        dueDate: "",
+        estimatedTime: "",
+        qaStatus: "",
+        gitLink: "",
+        gitLink1: "",
+        gitLink2: "",
+        expectedTime: "",
+        prLink: "",
+        storyPoints: "",
+    };
+}
+function resolveTextField(params) {
+    const mode = params.mode;
+    const customValue = (params.custom ?? "").trim();
+    // Custom textbox has priority: if user typed text, use it.
+    if (customValue.length) {
+        return customValue;
+    }
+    // Explicit default keeps existing default behavior.
+    if (mode === "default") {
+        return params.defaultValue;
+    }
+    // No selection means blank for optional fields.
+    if (params.allowBlank) {
+        return "";
+    }
+    return undefined;
+}
+function modeOptions(allowBlank) {
+    return ["default"];
+}
+function parseProjectSelection(value) {
+    const raw = value.trim();
+    const idPrefix = /^(\d+)\s*[-—]\s*/.exec(raw);
+    if (idPrefix) {
+        return idPrefix[1] ?? raw;
+    }
+    return raw;
+}
+function normalizeNone(value) {
+    const t = value.trim();
+    if (!t || /^(none|blank|skip|leave blank|n\/a)$/i.test(t)) {
+        return "";
+    }
+    return t;
+}
+function intakeComplete(input, draft) {
+    if (!draft.project || !draft.subject) {
+        return false;
+    }
+    if (input.tracker === undefined ||
+        input.status === undefined ||
+        input.priority === undefined) {
+        return false;
+    }
+    // Optional text fields should be allowed to be blank/omitted without causing
+    // another intake prompt; draft builder will normalize missing values to "".
+    return true;
+}
+async function buildFullIntakeQuestions(draft, config) {
+    const projectsData = await getProjects();
+    const projects = (projectsData.projects ?? []);
+    const projectOptions = projects.map((p) => `${p.id} — ${p.name}`);
+    const optionalHint = "(Default keeps default; use input value for custom; leave both empty for blank)";
+    return [
+        {
+            field: "project",
+            question: "Project *",
+            options: projectOptions,
+        },
+        {
+            field: "tracker",
+            question: "Tracker *",
+            options: enumerationOptions(config.trackers),
+        },
+        {
+            field: "subjectMode",
+            question: "Subject *",
+            options: ["default"],
+        },
+        {
+            field: "subjectCustom",
+            question: "Subject — input value (required)",
+        },
+        {
+            field: "status",
+            question: "Status *",
+            options: enumerationOptions(config.statuses),
+        },
+        {
+            field: "priority",
+            question: "Priority *",
+            options: enumerationOptions(config.priorities),
+        },
+        {
+            field: "descriptionMode",
+            question: `Description ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "descriptionCustom",
+            question: "Description — input value",
+        },
+        {
+            field: "assignedToMode",
+            question: `Assigned To ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "assignedToCustom",
+            question: "Assigned To — input value",
+        },
+        {
+            field: "targetVersionMode",
+            question: `Target version ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "targetVersionCustom",
+            question: "Target version — input value",
+        },
+        {
+            field: "parentTaskMode",
+            question: `Parent task (issue ID) ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "parentTaskCustom",
+            question: "Parent task — input value",
+        },
+        {
+            field: "startDateMode",
+            question: `Start date (default ${draft.startDate}) ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "startDateCustom",
+            question: "Start date — input value",
+        },
+        {
+            field: "dueDateMode",
+            question: `Due date ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "dueDateCustom",
+            question: "Due date — input value",
+        },
+        {
+            field: "estimatedTimeMode",
+            question: `Estimated time (hours or e.g. 3 days) ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "estimatedTimeCustom",
+            question: "Estimated time — input value",
+        },
+        {
+            field: "qaStatusMode",
+            question: `QA Status ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "qaStatusCustom",
+            question: "QA Status — input value",
+        },
+        {
+            field: "gitLinkMode",
+            question: `Git Link ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "gitLinkCustom",
+            question: "Git Link — input value",
+        },
+        {
+            field: "gitLink1Mode",
+            question: `Git Link1 ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "gitLink1Custom",
+            question: "Git Link1 — input value",
+        },
+        {
+            field: "gitLink2Mode",
+            question: `Git Link2 ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "gitLink2Custom",
+            question: "Git Link2 — input value",
+        },
+        {
+            field: "expectedTimeMode",
+            question: `Expected Time ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "expectedTimeCustom",
+            question: "Expected Time — input value",
+        },
+        {
+            field: "prLinkMode",
+            question: `PR Link ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "prLinkCustom",
+            question: "PR Link — input value",
+        },
+        {
+            field: "storyPointsMode",
+            question: `Story points ${optionalHint}`,
+            options: modeOptions(true),
+        },
+        {
+            field: "storyPointsCustom",
+            question: "Story points — input value",
+        },
+    ];
+}
+function normalizeDateToIso(value) {
+    const text = value.trim();
+    if (!text)
+        return undefined;
+    if (/^\d{4}-\d{2}-\d{2}$/.test(text))
+        return text;
+    const mmddyyyy = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(text);
+    if (mmddyyyy) {
+        return `${mmddyyyy[3]}-${mmddyyyy[1]}-${mmddyyyy[2]}`;
+    }
+    const parsed = new Date(text);
+    if (!Number.isNaN(parsed.getTime())) {
+        return parsed.toISOString().slice(0, 10);
+    }
+    return undefined;
+}
+function parseEstimatedTime(value) {
+    const trimmed = value.trim();
+    const daysMatch = /^(\d+(?:\.\d+)?)\s*days?$/i.exec(trimmed);
+    if (daysMatch) {
+        return Number(daysMatch[1]) * 8;
+    }
+    return parsePositiveNumber(trimmed);
+}
+function parsePositiveNumber(value) {
+    const parsed = Number(value.trim());
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return undefined;
+    return parsed;
+}
+function lookupIdByNameLocal(rows, name) {
+    return lookupIdByName(rows, name);
+}
+function validateEnumerationChoice(value, resolve, options, label) {
+    if (!value) {
+        return undefined;
+    }
+    if (resolve(value)) {
+        return undefined;
+    }
+    return `${label} must be one of: ${options.join(", ")}`;
+}
+function normalizeInput(input) {
+    const normalized = { ...input };
+    if (input.project) {
+        normalized.project = parseProjectSelection(input.project);
+    }
+    // Normalize custom text inputs
+    const customKeys = [
+        "subjectCustom",
+        "descriptionCustom",
+        "assignedToCustom",
+        "targetVersionCustom",
+        "parentTaskCustom",
+        "startDateCustom",
+        "dueDateCustom",
+        "estimatedTimeCustom",
+        "qaStatusCustom",
+        "gitLinkCustom",
+        "gitLink1Custom",
+        "gitLink2Custom",
+        "expectedTimeCustom",
+        "prLinkCustom",
+        "storyPointsCustom",
+    ];
+    for (const key of customKeys) {
+        const v = normalized[key];
+        if (typeof v === "string") {
+            normalized[key] = normalizeNone(v);
+        }
+    }
+    return normalized;
+}
+export async function createIssueWorkflow(input) {
+    const config = await loadRedmineConfig();
+    const normalizedInput = normalizeInput(input);
+    const baseDraft = buildDraft({
+        ...normalizedInput,
+        ...(normalizedInput.project
+            ? { project: parseProjectSelection(normalizedInput.project) }
+            : {}),
+    }, config);
+    const subject = resolveTextField({
+        mode: normalizedInput.subjectMode,
+        custom: normalizedInput.subjectCustom,
+        defaultValue: "",
+        allowBlank: false,
+    });
+    const description = resolveTextField({
+        mode: normalizedInput.descriptionMode,
+        custom: normalizedInput.descriptionCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const assignedTo = resolveTextField({
+        mode: normalizedInput.assignedToMode,
+        custom: normalizedInput.assignedToCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const targetVersion = resolveTextField({
+        mode: normalizedInput.targetVersionMode,
+        custom: normalizedInput.targetVersionCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const parentTask = resolveTextField({
+        mode: normalizedInput.parentTaskMode,
+        custom: normalizedInput.parentTaskCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const startDate = resolveTextField({
+        mode: normalizedInput.startDateMode,
+        custom: normalizedInput.startDateCustom,
+        defaultValue: todayMmDdYyyy(),
+        allowBlank: true,
+    });
+    const dueDate = resolveTextField({
+        mode: normalizedInput.dueDateMode,
+        custom: normalizedInput.dueDateCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const estimatedTime = resolveTextField({
+        mode: normalizedInput.estimatedTimeMode,
+        custom: normalizedInput.estimatedTimeCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const qaStatus = resolveTextField({
+        mode: normalizedInput.qaStatusMode,
+        custom: normalizedInput.qaStatusCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const gitLink = resolveTextField({
+        mode: normalizedInput.gitLinkMode,
+        custom: normalizedInput.gitLinkCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const gitLink1 = resolveTextField({
+        mode: normalizedInput.gitLink1Mode,
+        custom: normalizedInput.gitLink1Custom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const gitLink2 = resolveTextField({
+        mode: normalizedInput.gitLink2Mode,
+        custom: normalizedInput.gitLink2Custom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const expectedTime = resolveTextField({
+        mode: normalizedInput.expectedTimeMode,
+        custom: normalizedInput.expectedTimeCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const prLink = resolveTextField({
+        mode: normalizedInput.prLinkMode,
+        custom: normalizedInput.prLinkCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const storyPoints = resolveTextField({
+        mode: normalizedInput.storyPointsMode,
+        custom: normalizedInput.storyPointsCustom,
+        defaultValue: "",
+        allowBlank: true,
+    });
+    const draft = {
+        ...baseDraft,
+        subject: subject ?? "",
+        description: description ?? "",
+        assignedTo: assignedTo ?? "",
+        targetVersion: targetVersion ?? "",
+        parentTask: parentTask ?? "",
+        startDate: startDate && startDate.trim() ? startDate : todayMmDdYyyy(),
+        dueDate: dueDate ?? "",
+        estimatedTime: estimatedTime ?? "",
+        qaStatus: qaStatus ?? "",
+        gitLink: gitLink ?? "",
+        gitLink1: gitLink1 ?? "",
+        gitLink2: gitLink2 ?? "",
+        expectedTime: expectedTime ?? "",
+        prLink: prLink ?? "",
+        storyPoints: storyPoints ?? "",
+    };
+    const trackerResolved = resolveTracker(draft.tracker, config);
+    const statusResolved = resolveStatus(draft.status, config);
+    const priorityResolved = resolvePriority(draft.priority, config);
+    if (trackerResolved)
+        draft.tracker = trackerResolved.name;
+    if (statusResolved)
+        draft.status = statusResolved.name;
+    if (priorityResolved)
+        draft.priority = priorityResolved.name;
+    const configPayload = configOptionsPayload(config);
+    const choiceErrors = [
+        validateEnumerationChoice(draft.tracker, (v) => resolveTracker(v, config), configPayload.trackerOptions, "Tracker"),
+        validateEnumerationChoice(draft.status, (v) => resolveStatus(v, config), configPayload.statusOptions, "Status"),
+        validateEnumerationChoice(draft.priority, (v) => resolvePriority(v, config), configPayload.priorityOptions, "Priority"),
+    ].filter((e) => Boolean(e));
+    if (choiceErrors.length > 0) {
+        return {
+            success: false,
+            error: choiceErrors.join("; "),
+            data: {
+                draft,
+                ...configPayload,
+            },
+        };
+    }
+    if (!intakeComplete(normalizedInput, draft) || !normalizedInput.subjectMode) {
+        const questions = await buildFullIntakeQuestions(draft, config);
+        return {
+            success: false,
+            needsInput: true,
+            question: {
+                field: "createIssueBatch",
+                question: "Fill all fields in one AskQuestion. For text fields: choose Default/Leave Blank/Enter Custom, and provide the custom value in the paired input box.",
+            },
+            questions,
+            data: {
+                batchMode: true,
+                step: "collect_issue_fields",
+                draft,
+                ...configPayload,
+                hint: "Answer all questions in one go, then retry redmine_agent_create_issue with each field key set (use empty string to skip optional fields). Tracker aliases: CR→Change Request, bug→Bug, story→User Story.",
+            },
+        };
+    }
+    const startDateIso = normalizeDateToIso(draft.startDate);
+    const dueDateIso = draft.dueDate ? normalizeDateToIso(draft.dueDate) : undefined;
+    if (!startDateIso) {
+        return {
+            success: false,
+            error: "Start date must be MM/DD/YYYY, YYYY-MM-DD, or a parseable date",
+            data: { draft },
+        };
+    }
+    if (draft.dueDate && !dueDateIso) {
+        return {
+            success: false,
+            error: "Due date must be MM/DD/YYYY, YYYY-MM-DD, or a parseable date (e.g. 10 June 2026)",
+            data: { draft },
+        };
+    }
+    const estimatedHours = draft.estimatedTime
+        ? parseEstimatedTime(draft.estimatedTime)
+        : undefined;
+    if (draft.estimatedTime && estimatedHours === undefined) {
+        return {
+            success: false,
+            error: "Estimated time must be hours or a value like '3 days'",
+            data: { draft },
+        };
+    }
+    if (!normalizedInput.confirmSave) {
+        return {
+            success: false,
+            needsInput: true,
+            question: {
+                field: "confirmSave",
+                question: "Review the structured issue payload and confirm upload to Redmine.",
+                options: ["yes", "no"],
+            },
+            data: {
+                step: "preview",
+                draft,
+                structuredIssue: draft,
+                previewText: JSON.stringify(draft, null, 2),
+                summary: "Issue payload prepared. Confirm with confirmSave: yes to upload.",
+            },
+        };
+    }
+    if (normalizedInput.confirmSave !== "yes") {
+        return {
+            success: false,
+            error: "Issue creation cancelled by user",
+            data: { draft },
+        };
+    }
+    try {
+        const hasCustomFieldValues = draft.qaStatus ||
+            draft.gitLink ||
+            draft.gitLink1 ||
+            draft.gitLink2 ||
+            draft.expectedTime ||
+            draft.prLink ||
+            draft.storyPoints;
+        const [customFieldsData] = await Promise.all([
+            hasCustomFieldValues
+                ? getCustomFields().catch(() => ({ custom_fields: [] }))
+                : Promise.resolve({ custom_fields: [] }),
+        ]);
+        const trackerId = trackerResolved?.id;
+        const statusId = statusResolved?.id;
+        const priorityId = priorityResolved?.id;
+        if (!trackerId) {
+            return { success: false, error: `Tracker not found: ${draft.tracker}` };
+        }
+        if (!statusId) {
+            return { success: false, error: `Status not found: ${draft.status}` };
+        }
+        if (!priorityId) {
+            return { success: false, error: `Priority not found: ${draft.priority}` };
+        }
+        const customFields = (customFieldsData.custom_fields ?? []);
+        const warnings = [];
+        const assignedToId = draft.assignedTo
+            ? await resolveAssignedToId(draft.assignedTo, { projectId: draft.project })
+            : undefined;
+        if (draft.assignedTo && !assignedToId) {
+            warnings.push(`Assigned To "${draft.assignedTo}" could not be resolved and was omitted.`);
+        }
+        let fixedVersionId;
+        if (draft.targetVersion) {
+            const versionsData = await getProjectVersions(draft.project);
+            const versions = (versionsData.versions ?? []);
+            fixedVersionId = lookupIdByNameLocal(versions, draft.targetVersion);
+            if (!fixedVersionId) {
+                warnings.push(`Target version "${draft.targetVersion}" not found in project and was omitted.`);
+            }
+        }
+        const parentIssueId = draft.parentTask
+            ? parsePositiveNumber(draft.parentTask)
+            : undefined;
+        if (draft.parentTask && parentIssueId === undefined) {
+            warnings.push(`Parent task "${draft.parentTask}" is not a valid issue ID and was omitted.`);
+        }
+        const issueCustomFields = customFields.filter((cf) => !cf.customized_type ||
+            cf.customized_type === "Issue" ||
+            cf.customized_type === "issue");
+        const getCustomFieldId = (name) => lookupIdByNameLocal(issueCustomFields, name);
+        const customValues = [
+            { name: "QA Status", value: draft.qaStatus },
+            { name: "Git Link", value: draft.gitLink },
+            { name: "Git Link1", value: draft.gitLink1 },
+            { name: "Git Link2", value: draft.gitLink2 },
+            { name: "Expected Time", value: draft.expectedTime },
+            { name: "PR Link", value: draft.prLink },
+            { name: "Story points", value: draft.storyPoints },
+        ];
+        const mappedCustomFields = [];
+        for (const item of customValues) {
+            if (!item.value)
+                continue;
+            const id = getCustomFieldId(item.name);
+            if (!id) {
+                warnings.push(`Custom field "${item.name}" was not found and was omitted.`);
+                continue;
+            }
+            mappedCustomFields.push({ id, value: item.value });
+        }
+        const created = await createIssue({
+            projectId: draft.project,
+            trackerId,
+            subject: draft.subject,
+            statusId,
+            priorityId,
+            startDate: startDateIso,
+            ...(draft.description ? { description: draft.description } : {}),
+            ...(assignedToId !== undefined ? { assignedToId } : {}),
+            ...(fixedVersionId !== undefined ? { fixedVersionId } : {}),
+            ...(parentIssueId !== undefined ? { parentIssueId } : {}),
+            ...(dueDateIso !== undefined ? { dueDate: dueDateIso } : {}),
+            ...(estimatedHours !== undefined ? { estimatedHours } : {}),
+            ...(mappedCustomFields.length > 0
+                ? { customFields: mappedCustomFields }
+                : {}),
+        });
+        const issue = created.issue;
+        const { baseUrl } = requireRedmineEnv();
+        return {
+            success: true,
+            data: {
+                uploaded: true,
+                issueId: issue.id,
+                issueUrl: `${baseUrl}/issues/${issue.id}`,
+                structuredIssue: draft,
+                warnings,
+            },
+        };
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            const apiErrors = error.response?.data
+                ?.errors;
+            if (apiErrors && apiErrors.length > 0) {
+                return { success: false, error: apiErrors.join("; "), data: { draft } };
+            }
+            return {
+                success: false,
+                error: `Redmine create issue failed (${error.response?.status ?? "unknown status"})`,
+                data: { draft },
+            };
+        }
+        return {
+            success: false,
+            error: "Redmine create issue failed",
+            data: { draft },
+        };
+    }
+}
+//# sourceMappingURL=createIssueWorkflow.js.map