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

package/dist/workflows/batchCreateIssuesWorkflow.js

@@ -0,0 +1,1102 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { extractRawBatchSheet } from "../spreadsheet/extractRawBatchSheet.js";
+import { BATCH_COLUMN_FIELD_SCHEMA, buildColumnMappingQuestions, buildMappingPreview, parseBatchWithColumnMapping, STEPS_TO_REPRODUCE_RULE, suggestColumnMappingFromHeaders, validateColumnMapping, } from "../spreadsheet/batchColumnMapping.js";
+import { BATCH_CREATE_LEVEL_ORDER, } from "../spreadsheet/batchCreationTypes.js";
+import { buildPreviewMermaidDiagram, buildPreviewOverview, buildPreviewTree, } from "../spreadsheet/batchPreviewFormat.js";
+import { loadAssigneeDirectory, matchAssigneeId, } from "../services/assigneeDirectory.js";
+import { columnIndexToLetter } from "../services/googleSheets.js";
+import { createProjectVersion, getProjects, getProjectVersions, } from "../services/redmine.js";
+import { enumerationOptions, loadRedmineConfig, STEPS_TO_REPRODUCE_TRACKER_NAMES, } from "../services/redmineConfig.js";
+import { enrichBatchIssuesFromConfig } from "../spreadsheet/batchIssueConfig.js";
+import { createRedmineIssueFromBatch, parseProjectSelection, } from "./issueCreationHelpers.js";
+import { findFeatureTitleColumnIndex } from "../spreadsheet/featureRow.js";
+import { resolveTaskIdColumnForWriteBack, TASK_ID_COLUMN_HEADER, usesCompositeTicketColumn, } from "../spreadsheet/sheetColumnMap.js";
+/** AskQuestion option: user skips the row (agent adds nodeId to skipNodeIds). */
+export const ASSIGNEE_SKIP_OPTION = "Skip this row";
+/** AskQuestion option: create row without assigned_to (clear invalid sheet label). */
+export const ASSIGNEE_UNASSIGNED_OPTION = "Leave unassigned";
+/** AskQuestion option: create user story without fixed_version. */
+export const TARGET_VERSION_SKIP_OPTION = "Skip target version";
+/** Agent retry: `Create: <name>` creates a project version with that name (e.g. user typed name via AskQuestion Other). */
+const TARGET_VERSION_CREATE_PREFIX = /^Create:\s*(.+)$/i;
+const DEFAULT_STATUS = "New";
+const DEFAULT_PRIORITY = "Normal";
+/** Above this, UI should ask show_preview / proceed / cancel instead of dumping full preview. */
+const PREVIEW_LONG_MIN_ISSUES = 8;
+const PREVIEW_LONG_MIN_CHARS = 1200;
+function applyExistingNodeIds(issues, existing) {
+    if (!existing)
+        return issues;
+    return issues.map((issue) => {
+        const id = existing[issue.nodeId];
+        if (id === undefined)
+            return issue;
+        return { ...issue, existingRedmineId: id };
+    });
+}
+function applyRowFixes(issues, fixes) {
+    if (!fixes)
+        return issues;
+    return issues.map((issue) => {
+        const fix = fixes[issue.nodeId];
+        if (!fix)
+            return issue;
+        return {
+            ...issue,
+            ...(fix.subject !== undefined ? { subject: fix.subject.trim() } : {}),
+            ...(fix.assignedTo !== undefined
+                ? { assignedTo: fix.assignedTo.trim() }
+                : {}),
+            ...(fix.targetVersion !== undefined
+                ? { targetVersion: fix.targetVersion.trim() }
+                : {}),
+        };
+    });
+}
+function findMissingTargetVersionStories(issues, skipSet) {
+    return issues.filter((issue) => issue.level === "userStory" &&
+        !issue.targetVersion.trim() &&
+        issue.existingRedmineId === undefined &&
+        !skipSet.has(issue.nodeId));
+}
+function applyMissingTargetVersionFix(issues, fix, missingStories) {
+    if (!fix?.trim() || missingStories.length === 0)
+        return issues;
+    if (fix.trim() === TARGET_VERSION_SKIP_OPTION)
+        return issues;
+    const missingIds = new Set(missingStories.map((m) => m.nodeId));
+    const version = fix.trim();
+    return issues.map((issue) => missingIds.has(issue.nodeId) ? { ...issue, targetVersion: version } : issue);
+}
+async function loadProjectVersionOptions(projectId) {
+    const data = await getProjectVersions(projectId);
+    const versions = (data.versions ?? []);
+    return versions.map((v) => `${v.id} — ${v.name}`);
+}
+async function resolveMissingTargetVersionFix(params) {
+    const fix = params.fix.trim();
+    if (!fix) {
+        return {
+            ok: false,
+            error: "Target version selection is required.",
+        };
+    }
+    if (fix === TARGET_VERSION_SKIP_OPTION) {
+        return { ok: true, resolved: fix };
+    }
+    const createPrefixMatch = TARGET_VERSION_CREATE_PREFIX.exec(fix);
+    const createName = createPrefixMatch?.[1]?.trim() || "";
+    if (createPrefixMatch !== null) {
+        if (!createName) {
+            return {
+                ok: false,
+                error: 'Enter a version name via AskQuestion Other, then retry with missingTargetVersionFix: "Create: <name>".',
+            };
+        }
+        try {
+            const created = await createProjectVersion(params.projectId, createName);
+            return {
+                ok: true,
+                resolved: `${created.id} — ${created.name}`,
+                created,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error
+                ? err.message
+                : "Failed to create target version in Redmine.";
+            return {
+                ok: false,
+                error: `Could not create target version "${createName}": ${message}`,
+            };
+        }
+    }
+    return { ok: true, resolved: fix };
+}
+function applyAssigneeNameFixes(issues, nameFixes, skipSet) {
+    if (!nameFixes || Object.keys(nameFixes).length === 0) {
+        return issues;
+    }
+    return issues.map((issue) => {
+        if (issue.level !== "subtask")
+            return issue;
+        const sheetLabel = issue.assignedTo.trim();
+        if (!sheetLabel)
+            return issue;
+        const fix = nameFixes[sheetLabel];
+        if (fix === undefined)
+            return issue;
+        if (fix.trim() === ASSIGNEE_SKIP_OPTION) {
+            skipSet.add(issue.nodeId);
+            return issue;
+        }
+        if (fix.trim() === ASSIGNEE_UNASSIGNED_OPTION) {
+            return { ...issue, assignedTo: "" };
+        }
+        return { ...issue, assignedTo: fix.trim() };
+    });
+}
+function applyPriorityNameFixes(issues, nameFixes) {
+    if (!nameFixes || Object.keys(nameFixes).length === 0) {
+        return issues;
+    }
+    return issues.map((issue) => {
+        const sheetLabel = issue.priority?.trim();
+        if (!sheetLabel)
+            return issue;
+        const fix = nameFixes[sheetLabel];
+        if (fix === undefined)
+            return issue;
+        return { ...issue, priority: fix.trim() };
+    });
+}
+function applyTrackerNameFixes(issues, nameFixes) {
+    if (!nameFixes || Object.keys(nameFixes).length === 0) {
+        return issues;
+    }
+    return issues.map((issue) => {
+        const sheetLabel = issue.sheetType?.trim();
+        if (!sheetLabel)
+            return issue;
+        const fix = nameFixes[sheetLabel];
+        if (fix === undefined)
+            return issue;
+        return { ...issue, sheetType: fix.trim() };
+    });
+}
+function applyStatusNameFixes(issues, nameFixes) {
+    if (!nameFixes || Object.keys(nameFixes).length === 0) {
+        return issues;
+    }
+    return issues.map((issue) => {
+        const sheetLabel = issue.status?.trim();
+        if (!sheetLabel)
+            return issue;
+        const fix = nameFixes[sheetLabel];
+        if (fix === undefined)
+            return issue;
+        return { ...issue, status: fix.trim() };
+    });
+}
+function resolveAssigneeLabel(assignedTo, users) {
+    const trimmed = assignedTo.trim();
+    if (!trimmed)
+        return { label: "" };
+    if (!users?.length)
+        return { label: trimmed };
+    const id = matchAssigneeId(trimmed, users);
+    if (id === undefined)
+        return { label: trimmed };
+    const member = users.find((u) => u.id === id);
+    return { id, label: member?.label ?? trimmed };
+}
+/**
+ * Mandatory: when every non-skipped Task under a User Story has the same assignee
+ * (matched by member id when directory is available, else exact label), set that
+ * assignee on the User Story too.
+ */
+function propagateAssigneeToUserStories(issues, skipSet, users) {
+    return issues.map((issue) => {
+        if (issue.level !== "userStory")
+            return issue;
+        if (skipSet.has(issue.nodeId))
+            return issue;
+        const subtasks = issues.filter((s) => s.level === "subtask" &&
+            s.parentNodeId === issue.nodeId &&
+            !skipSet.has(s.nodeId));
+        if (subtasks.length === 0)
+            return issue;
+        const resolved = subtasks.map((s) => resolveAssigneeLabel(s.assignedTo, users));
+        if (resolved.some((r) => !r.label))
+            return issue;
+        const ids = resolved.map((r) => r.id ?? r.label);
+        const unique = new Set(ids);
+        if (unique.size !== 1)
+            return issue;
+        const canonical = resolved[0].label;
+        return { ...issue, assignedTo: canonical };
+    });
+}
+function groupInvalidAssigneesByName(invalidAssignees) {
+    const byName = new Map();
+    for (const issue of invalidAssignees) {
+        const key = issue.assignedTo.trim();
+        const list = byName.get(key) ?? [];
+        list.push(issue);
+        byName.set(key, list);
+    }
+    return [...byName.entries()].map(([assignedTo, group]) => ({
+        assignedTo,
+        nodeIds: group.map((i) => i.nodeId),
+        rowIndexes: group.map((i) => i.rowIndex).sort((a, b) => a - b),
+    }));
+}
+function assigneeFixQuestionId(sheetLabel) {
+    return `assignee-name-${encodeURIComponent(sheetLabel)}`;
+}
+function buildPreviewRows(issues, skipSet) {
+    return issues.map((i) => ({
+        nodeId: i.nodeId,
+        rowIndex: i.rowIndex,
+        level: i.level,
+        tracker: i.tracker,
+        subject: i.subject,
+        descriptionLength: i.description.length,
+        parentNodeId: i.parentNodeId,
+        ...(i.estimatedHours !== undefined ? { estimatedHours: i.estimatedHours } : {}),
+        targetVersion: i.targetVersion,
+        assignedTo: i.assignedTo,
+        system: i.system,
+        skipped: skipSet.has(i.nodeId),
+        onRedmine: Boolean(i.existingRedmineId),
+        ...(i.existingRedmineId !== undefined
+            ? { existingRedmineId: i.existingRedmineId }
+            : {}),
+        ...(i.status ? { status: i.status } : {}),
+    }));
+}
+function partitionIssues(issues, skipSet) {
+    const active = issues.filter((i) => !skipSet.has(i.nodeId));
+    const alreadyOnRedmine = active.filter((i) => i.existingRedmineId !== undefined);
+    const toCreate = sortIssuesForUpload(active.filter((i) => i.existingRedmineId === undefined));
+    return { active, alreadyOnRedmine, toCreate };
+}
+function isPreviewLong(previewText, issueCount) {
+    return (issueCount > PREVIEW_LONG_MIN_ISSUES ||
+        previewText.length > PREVIEW_LONG_MIN_CHARS ||
+        previewText.split("\n").length > PREVIEW_LONG_MIN_ISSUES);
+}
+function buildPreviewSummary(rows, toCreateCount, skippedCount, alreadyOnRedmineCount, featureTitle) {
+    const active = rows.filter((r) => !r.skipped);
+    const features = active.filter((r) => r.level === "feature");
+    const stories = active.filter((r) => r.level === "userStory");
+    const subtaskCount = active.filter((r) => r.level === "subtask").length;
+    const newStories = stories.filter((r) => !r.onRedmine).length;
+    const newTasks = active.filter((r) => r.level === "subtask" && !r.onRedmine).length;
+    const title = featureTitle ?? features[0]?.subject;
+    const lines = [];
+    if (title) {
+        lines.push(`Feature "${title}": create ${toCreateCount} new issue(s) (${newStories} User Story(ies), ${newTasks} Task(s)).`);
+    }
+    else {
+        lines.push(`Create ${toCreateCount} new issue(s): ${newStories} User Story(ies), ${newTasks} Task(s).`);
+    }
+    if (alreadyOnRedmineCount > 0) {
+        lines.push(`${alreadyOnRedmineCount} row(s) already on Redmine (Task ID set) — will not upload.`);
+    }
+    if (skippedCount > 0) {
+        lines.push(`${skippedCount} row(s) skipped.`);
+    }
+    lines.push("");
+    for (const story of stories) {
+        const subs = active.filter((r) => r.parentNodeId === story.nodeId);
+        const eta = story.estimatedHours !== undefined
+            ? ` (${story.estimatedHours}h)`
+            : "";
+        const version = story.targetVersion
+            ? ` · version: ${story.targetVersion}`
+            : "";
+        const storyAssign = story.assignedTo ? ` · assignee: ${story.assignedTo}` : "";
+        lines.push(`• User Story [row ${story.rowIndex}] ${story.subject}${eta}${version}${storyAssign} → ${subs.length} Task(s)`);
+    }
+    return lines.join("\n");
+}
+function sortIssuesForUpload(issues) {
+    return [...issues].sort((a, b) => BATCH_CREATE_LEVEL_ORDER[a.level] -
+        BATCH_CREATE_LEVEL_ORDER[b.level]);
+}
+function buildPreviewText(rows) {
+    const lines = rows.map((r) => {
+        const skip = r.skipped ? " [SKIP]" : "";
+        const onRedmine = r.onRedmine
+            ? ` [ON REDMINE #${r.existingRedmineId}]`
+            : "";
+        const parent = r.parentNodeId ? ` parent=${r.parentNodeId}` : "";
+        const eta = r.estimatedHours !== undefined ? ` ETA=${r.estimatedHours}h` : "";
+        const desc = r.descriptionLength > 0 ? ` desc=${r.descriptionLength}ch` : "";
+        const version = r.targetVersion && r.level === "userStory"
+            ? ` version=${r.targetVersion}`
+            : "";
+        const assign = r.assignedTo &&
+            (r.level === "subtask" || r.level === "userStory")
+            ? ` assignee=${r.assignedTo}`
+            : "";
+        const levelLabel = r.level === "feature"
+            ? "Feature"
+            : r.level === "userStory"
+                ? "User Story"
+                : "Task";
+        return `- row ${r.rowIndex} [${levelLabel}] ${r.tracker}: ${r.subject}${eta}${version}${assign}${desc}${parent}${onRedmine}${skip}`;
+    });
+    return lines.join("\n");
+}
+function emptySubjectQuestions(issues) {
+    const questions = [];
+    for (const issue of issues) {
+        if (!issue.subject) {
+            questions.push({
+                id: issue.nodeId,
+                field: `rowFixes.${issue.nodeId}.subject`,
+                question: `Row ${issue.rowIndex} (${issue.level}): subject is empty — provide text`,
+            });
+        }
+    }
+    return questions;
+}
+function groupUnresolvedByLabel(items) {
+    const groups = new Map();
+    for (const item of items) {
+        const group = groups.get(item.label) ?? { nodeIds: [], rowIndexes: [] };
+        group.nodeIds.push(item.nodeId);
+        group.rowIndexes.push(item.rowIndex);
+        groups.set(item.label, group);
+    }
+    return [...groups.entries()].map(([label, group]) => ({
+        label,
+        nodeIds: group.nodeIds,
+        rowIndexes: group.rowIndexes,
+    }));
+}
+function priorityValidationQuestions(unresolvedPriorities, priorityOptions) {
+    return groupUnresolvedByLabel(unresolvedPriorities).map((group) => {
+        const rowList = group.rowIndexes.join(", ");
+        return {
+            id: `priority-name-${group.label}`,
+            field: `priorityNameFixes.${group.label}`,
+            question: `Priority "${group.label}" is not in Redmine config (${group.nodeIds.length} row(s): ${rowList}). Pick the matching priority from config.`,
+            options: priorityOptions,
+        };
+    });
+}
+function trackerValidationQuestions(unresolvedTrackers, trackerOptions) {
+    return groupUnresolvedByLabel(unresolvedTrackers).map((group) => {
+        const rowList = group.rowIndexes.join(", ");
+        return {
+            id: `tracker-name-${group.label}`,
+            field: `trackerNameFixes.${group.label}`,
+            question: `Type/tracker "${group.label}" is not in Redmine config (${group.nodeIds.length} row(s): ${rowList}). Pick the matching tracker from config.`,
+            options: trackerOptions,
+        };
+    });
+}
+function statusValidationQuestions(unresolvedStatuses, statusOptions) {
+    return groupUnresolvedByLabel(unresolvedStatuses).map((group) => {
+        const rowList = group.rowIndexes.join(", ");
+        return {
+            id: `status-name-${group.label}`,
+            field: `statusNameFixes.${group.label}`,
+            question: `Status "${group.label}" is not in Redmine config (${group.nodeIds.length} row(s): ${rowList}). Pick the matching status from config.`,
+            options: statusOptions,
+        };
+    });
+}
+function assigneeValidationQuestions(invalidAssignees, assigneeOptions) {
+    const assigneeChoices = [
+        ...assigneeOptions,
+        ASSIGNEE_UNASSIGNED_OPTION,
+        ASSIGNEE_SKIP_OPTION,
+    ];
+    return groupInvalidAssigneesByName(invalidAssignees).map((group) => {
+        const rowList = group.rowIndexes.join(", ");
+        return {
+            id: assigneeFixQuestionId(group.assignedTo),
+            field: `assigneeNameFixes.${group.assignedTo}`,
+            question: `Assigned To "${group.assignedTo}" is not a project member (${group.nodeIds.length} task row(s): ${rowList}). Pick the correct assignee, leave unassigned, or skip all rows.`,
+            options: assigneeChoices,
+        };
+    });
+}
+async function loadProjectOptions() {
+    const projectsData = await getProjects();
+    const projects = (projectsData.projects ?? []);
+    return {
+        projects,
+        projectOptions: projects.map((p) => `${p.id} — ${p.name}`),
+    };
+}
+async function pickProjectResponse(params) {
+    const { projectOptions } = await loadProjectOptions();
+    return {
+        success: false,
+        needsInput: true,
+        question: {
+            field: "project",
+            question: "Select the Redmine project for this batch *",
+            options: projectOptions,
+        },
+        data: {
+            step: "pick_project",
+            projectOptions,
+            featureTitle: params.rawSheet.featureTitle,
+            detectedHeaderRowIndex: params.rawSheet.detectedHeaderRowIndex,
+            detectedHeaders: params.rawSheet.detectedHeaders,
+            ...(params.loaded.sheetSource
+                ? { sheetSource: params.loaded.sheetSource }
+                : {}),
+            hint: "STOP: AskQuestion for project first. Retry with project (id or \"id — name\"). Do NOT map columns until project is set.",
+        },
+    };
+}
+async function pickTargetVersionResponse(params) {
+    let versionOptions = [];
+    try {
+        versionOptions = await loadProjectVersionOptions(params.projectId);
+    }
+    catch {
+        versionOptions = [];
+    }
+    const versionChoices = [...versionOptions, TARGET_VERSION_SKIP_OPTION];
+    return {
+        success: false,
+        needsInput: true,
+        question: {
+            field: "missingTargetVersionFix",
+            question: versionOptions.length > 0
+                ? "Pick the default target version for this batch. Rows with a Target Version column value use that instead. Choose Skip target version to continue without fixed_version, or pick Other and type a new version name."
+                : "This project has no target versions yet. Choose Skip target version to continue without fixed_version, or pick Other and type a new version name to create one.",
+            options: versionChoices,
+        },
+        data: {
+            step: "pick_target_version",
+            project: params.projectId,
+            versionOptions,
+            targetVersionSkipOption: TARGET_VERSION_SKIP_OPTION,
+            featureTitle: params.rawSheet.featureTitle,
+            detectedHeaderRowIndex: params.rawSheet.detectedHeaderRowIndex,
+            detectedHeaders: params.rawSheet.detectedHeaders,
+            ...(params.loaded.sheetSource
+                ? { sheetSource: params.loaded.sheetSource }
+                : {}),
+            hint: 'STOP: Always AskQuestion for batch default target version — never infer from missing sheet column. Retry with missingTargetVersionFix: existing "id — name", "Skip target version", or "Create: <name>" when user typed a new name via Other.',
+        },
+    };
+}
+async function findInvalidAssignees(issues, projectId, skipSet) {
+    const numericProjectId = Number(projectId);
+    const directory = await loadAssigneeDirectory(Number.isFinite(numericProjectId) ? { projectId: numericProjectId } : {});
+    const assigneeOptions = directory.users.map((u) => u.label);
+    const invalid = issues.filter((issue) => {
+        if (issue.level !== "subtask")
+            return false;
+        if (issue.existingRedmineId !== undefined)
+            return false;
+        if (skipSet.has(issue.nodeId))
+            return false;
+        const assignedTo = issue.assignedTo.trim();
+        if (!assignedTo)
+            return false;
+        return matchAssigneeId(assignedTo, directory.users) === undefined;
+    });
+    return { invalid, assigneeOptions };
+}
+async function mapColumnsResponse(params) {
+    const config = await loadRedmineConfig();
+    const suggestedColumnMapping = suggestColumnMappingFromHeaders(params.rawSheet.detectedHeaders, params.rawSheet.detectedHeaderRowIndex);
+    const sampleRows = params.rawSheet.rows
+        .filter((r) => r.sheetRow > params.rawSheet.detectedHeaderRowIndex + 1)
+        .slice(0, 12)
+        .map((r) => ({
+        sheetRow: r.sheetRow,
+        cells: r.cells,
+    }));
+    return {
+        success: false,
+        needsInput: true,
+        question: {
+            field: "columnMapping",
+            question: "Use suggestedColumnMapping (or adjust), then retry with columnMapping → confirm_mapping. Required: userStory + subtask.",
+        },
+        data: {
+            step: "map_columns",
+            ...(params.projectId ? { project: params.projectId } : {}),
+            ...(params.missingTargetVersionFix !== undefined
+                ? { missingTargetVersionFix: params.missingTargetVersionFix }
+                : {}),
+            ...(params.createdTargetVersion
+                ? { createdTargetVersion: params.createdTargetVersion }
+                : {}),
+            featureTitle: params.rawSheet.featureTitle,
+            detectedHeaderRowIndex: params.rawSheet.detectedHeaderRowIndex,
+            detectedHeaders: params.rawSheet.detectedHeaders,
+            suggestedColumnMapping,
+            fieldSchema: BATCH_COLUMN_FIELD_SCHEMA,
+            stepsToReproduceRule: STEPS_TO_REPRODUCE_RULE,
+            sampleRows,
+            totalDataRows: params.rawSheet.rows.length -
+                params.rawSheet.detectedHeaderRowIndex -
+                1,
+            ...(params.loaded.sheetSource
+                ? { sheetSource: params.loaded.sheetSource }
+                : {}),
+            trackerOptions: enumerationOptions(config.trackers),
+            priorityOptions: enumerationOptions(config.priorities),
+            trackerAliases: config.trackerAliases,
+            priorityAliases: config.priorityAliases,
+            stepsToReproduceTrackers: [...STEPS_TO_REPRODUCE_TRACKER_NAMES],
+            hint: "STOP: Use data.suggestedColumnMapping as columnMapping (User Stories→userStory, Tasks→subtask). If ambiguousRoles is non-empty, AskQuestion. Then confirm_mapping.",
+        },
+    };
+}
+function confirmMappingResponse(params) {
+    const headers = params.rawSheet.rows[params.mapping.headerRowIndex]?.cells ??
+        params.rawSheet.detectedHeaders;
+    const mappingPreview = buildMappingPreview(params.mapping, headers);
+    const questions = [
+        {
+            id: "confirm-column-mapping",
+            field: "confirmMappingAction",
+            question: "Use this column mapping to parse the sheet and build the issue preview?",
+            options: ["proceed with this mapping", "change mapping"],
+        },
+    ];
+    return {
+        success: false,
+        needsInput: true,
+        questions,
+        data: {
+            batchMode: true,
+            step: "confirm_mapping",
+            columnMapping: params.mapping,
+            mappingPreview,
+            detectedHeaderRowIndex: params.mapping.headerRowIndex,
+            detectedHeaders: headers,
+            fieldSchema: BATCH_COLUMN_FIELD_SCHEMA,
+            stepsToReproduceRule: STEPS_TO_REPRODUCE_RULE,
+            featureTitle: params.rawSheet.featureTitle,
+            ...(params.loaded.sheetSource
+                ? { sheetSource: params.loaded.sheetSource }
+                : {}),
+            hint: 'STOP: Post mappingPreview (includes Steps to Reproduce sources). ONE AskQuestion proceed/change. Never map a Steps to Reproduce column — use comments/description roles per stepsToReproduceRule.',
+        },
+    };
+}
+function fixColumnMappingResponse(params) {
+    const questions = buildColumnMappingQuestions(params.validation);
+    const mappingProblems = params.validation.problems.map((p) => ({
+        role: p.role,
+        issue: p.issue,
+        ...(p.spec !== undefined ? { spec: p.spec } : {}),
+    }));
+    return {
+        success: false,
+        needsInput: true,
+        questions,
+        data: {
+            batchMode: true,
+            step: "fix_column_mapping",
+            mappingProblems,
+            detectedHeaders: params.validation.detectedHeaders,
+            headerRowIndex: params.validation.headerRowIndex,
+            fieldSchema: BATCH_COLUMN_FIELD_SCHEMA,
+            stepsToReproduceRule: STEPS_TO_REPRODUCE_RULE,
+            ...(params.mapping ? { columnMapping: params.mapping } : {}),
+            ...(params.parseWarnings?.length
+                ? { parseWarnings: params.parseWarnings }
+                : {}),
+            ...(params.loaded.sheetSource ? { sheetSource: params.loaded.sheetSource } : {}),
+            hint: params.hint ??
+                "STOP: ONE AskQuestion for all questions[]. Map userStory + subtask required. stepsToReproduceRule — map comments/description; no separate Steps to Reproduce column.",
+        },
+    };
+}
+async function loadCsvContent(input) {
+    const sheetSource = input.sheetSource;
+    if (input.csvContent?.trim()) {
+        return {
+            content: input.csvContent,
+            ...(sheetSource ? { sheetSource } : {}),
+        };
+    }
+    if (input.csvPath?.trim()) {
+        try {
+            const path = resolve(input.csvPath.trim());
+            const content = await readFile(path, "utf8");
+            return {
+                content,
+                ...(sheetSource ? { sheetSource } : {}),
+            };
+        }
+        catch {
+            return { error: `Could not read csvPath: ${input.csvPath}` };
+        }
+    }
+    return {
+        error: "Provide csvContent (from redmine_agent_sheet_to_csv) or csvPath",
+    };
+}
+export async function batchCreateIssuesWorkflow(input) {
+    const status = input.status?.trim() || DEFAULT_STATUS;
+    const priority = input.priority?.trim() || DEFAULT_PRIORITY;
+    const skipSet = new Set(input.skipNodeIds ?? []);
+    const loaded = await loadCsvContent(input);
+    if (loaded.error || !loaded.content) {
+        return { success: false, error: loaded.error ?? "No CSV content" };
+    }
+    const rawSheet = extractRawBatchSheet(loaded.content);
+    if (!input.project?.trim()) {
+        return pickProjectResponse({ rawSheet, loaded });
+    }
+    const projectId = parseProjectSelection(input.project);
+    if (!projectId) {
+        return {
+            success: false,
+            error: `Invalid project selection: ${input.project}`,
+        };
+    }
+    if (input.missingTargetVersionFix === undefined) {
+        return pickTargetVersionResponse({ projectId, rawSheet, loaded });
+    }
+    const versionResolve = await resolveMissingTargetVersionFix({
+        projectId,
+        fix: input.missingTargetVersionFix,
+    });
+    if (!versionResolve.ok) {
+        return { success: false, error: versionResolve.error };
+    }
+    const resolvedTargetVersionFix = versionResolve.resolved;
+    if (input.sheetParseMode === "structure_only" || !input.columnMapping) {
+        return await mapColumnsResponse({
+            rawSheet,
+            loaded,
+            projectId,
+            missingTargetVersionFix: resolvedTargetVersionFix,
+            ...(versionResolve.created
+                ? { createdTargetVersion: versionResolve.created }
+                : {}),
+        });
+    }
+    const mappingValidation = validateColumnMapping(rawSheet, input.columnMapping);
+    if (!mappingValidation.valid) {
+        return fixColumnMappingResponse({
+            rawSheet,
+            mapping: input.columnMapping,
+            validation: mappingValidation,
+            loaded,
+        });
+    }
+    if (input.confirmMappingAction !== "proceed") {
+        return confirmMappingResponse({
+            rawSheet,
+            mapping: input.columnMapping,
+            loaded,
+        });
+    }
+    const parsed = parseBatchWithColumnMapping(rawSheet, input.columnMapping);
+    if (parsed.headerRowIndex < 0 || parsed.issues.length === 0) {
+        const emptyParseProblems = [
+            ...mappingValidation.problems,
+            {
+                role: "userStory",
+                issue: parsed.parseWarnings[0] ??
+                    "No User Stories or Tasks parsed — check userStory and subtask columns match data rows.",
+            },
+        ];
+        return fixColumnMappingResponse({
+            rawSheet,
+            mapping: input.columnMapping,
+            validation: {
+                ...mappingValidation,
+                valid: false,
+                problems: emptyParseProblems,
+            },
+            loaded,
+            parseWarnings: parsed.parseWarnings,
+            hint: "STOP: Mapping resolved but no issues were parsed. ONE AskQuestion for all questions[], then retry with corrected columnMapping.",
+        });
+    }
+    let issues = applyRowFixes(parsed.issues, input.rowFixes);
+    const missingTargetVersionsEarly = findMissingTargetVersionStories(issues, skipSet);
+    issues = applyMissingTargetVersionFix(issues, resolvedTargetVersionFix, missingTargetVersionsEarly);
+    issues = applyAssigneeNameFixes(issues, input.assigneeNameFixes, skipSet);
+    issues = applyPriorityNameFixes(issues, input.priorityNameFixes);
+    issues = applyTrackerNameFixes(issues, input.trackerNameFixes);
+    issues = applyStatusNameFixes(issues, input.statusNameFixes);
+    issues = applyExistingNodeIds(issues, input.existingNodeIds);
+    issues = propagateAssigneeToUserStories(issues, skipSet);
+    const config = await loadRedmineConfig();
+    const configEnrichment = enrichBatchIssuesFromConfig(issues, config, {
+        priority,
+        status,
+    });
+    issues = configEnrichment.issues;
+    if (configEnrichment.warnings.length > 0) {
+        parsed.parseWarnings.push(...configEnrichment.warnings);
+    }
+    if (configEnrichment.unresolvedTrackers.length > 0 ||
+        configEnrichment.unresolvedPriorities.length > 0 ||
+        configEnrichment.unresolvedStatuses.length > 0) {
+        const trackerOptions = config.trackers.map((t) => `${t.id} — ${t.name}`);
+        const priorityOptions = config.priorities.map((p) => `${p.id} — ${p.name}`);
+        const statusOptions = config.statuses.map((s) => `${s.id} — ${s.name}`);
+        const questions = [
+            ...priorityValidationQuestions(configEnrichment.unresolvedPriorities, priorityOptions),
+            ...trackerValidationQuestions(configEnrichment.unresolvedTrackers, trackerOptions),
+            ...statusValidationQuestions(configEnrichment.unresolvedStatuses, statusOptions),
+        ];
+        return {
+            success: false,
+            needsInput: true,
+            ...(questions.length > 0 ? { questions } : {}),
+            error: "Some sheet Type, Priority, or Status values do not match Redmine config.",
+            data: {
+                step: "fix_batch_gaps",
+                batchMode: true,
+                format: parsed.format,
+                parseWarnings: parsed.parseWarnings,
+                unresolvedTrackers: configEnrichment.unresolvedTrackers,
+                unresolvedPriorities: configEnrichment.unresolvedPriorities,
+                unresolvedStatuses: configEnrichment.unresolvedStatuses,
+                trackerOptions,
+                priorityOptions,
+                statusOptions,
+                priorityAliases: config.priorityAliases,
+                trackerAliases: config.trackerAliases,
+                statusAliases: config.statusAliases,
+                hint: "STOP: ONE AskQuestion for all questions[]. Retry with priorityNameFixes / trackerNameFixes / statusNameFixes from config options. Do NOT search repo files.",
+            },
+        };
+    }
+    const { alreadyOnRedmine, toCreate: toCreateNew } = partitionIssues(issues, skipSet);
+    const { projects } = await loadProjectOptions();
+    const needsSubjectFix = issues.some((i) => !i.subject.trim());
+    const assigneeCheck = await findInvalidAssignees(issues, projectId, skipSet);
+    const invalidAssignees = assigneeCheck.invalid;
+    const assigneeOptions = assigneeCheck.assigneeOptions;
+    if (needsSubjectFix) {
+        const questions = emptySubjectQuestions(issues);
+        if (questions.length > 0) {
+            return {
+                success: false,
+                needsInput: true,
+                questions,
+                data: {
+                    batchMode: true,
+                    step: "fix_batch_gaps",
+                    format: parsed.format,
+                    parseWarnings: parsed.parseWarnings,
+                    scopeNotes: parsed.scopeNotes,
+                    issueCount: toCreateNew.length,
+                    alreadyOnRedmineCount: alreadyOnRedmine.length,
+                    trackerMapping: getTrackerMapping(),
+                    featureTitle: parsed.featureTitle ?? null,
+                    ...(loaded.sheetSource ? { sheetSource: loaded.sheetSource } : {}),
+                    hint: "Answer all questions in one AskQuestion, then retry with rowFixes.",
+                },
+            };
+        }
+    }
+    if (invalidAssignees.length > 0) {
+        const questions = assigneeValidationQuestions(invalidAssignees, assigneeOptions);
+        return {
+            success: false,
+            needsInput: true,
+            questions,
+            data: {
+                batchMode: true,
+                step: "fix_assignees",
+                format: parsed.format,
+                parseWarnings: parsed.parseWarnings,
+                scopeNotes: parsed.scopeNotes,
+                issueCount: toCreateNew.length,
+                alreadyOnRedmineCount: alreadyOnRedmine.length,
+                trackerMapping: getTrackerMapping(),
+                featureTitle: parsed.featureTitle ?? null,
+                project: projectId,
+                ...(loaded.sheetSource ? { sheetSource: loaded.sheetSource } : {}),
+                invalidAssigneeGroups: groupInvalidAssigneesByName(invalidAssignees),
+                assigneeOptions,
+                hint: "STOP: ONE AskQuestion for all assignee questions. Retry with assigneeNameFixes per invalidAssigneeGroups name. Do NOT auto-guess.",
+            },
+        };
+    }
+    if (projectId) {
+        const directory = await loadAssigneeDirectory({
+            projectId: Number(projectId),
+        });
+        issues = propagateAssigneeToUserStories(issues, skipSet, directory.users);
+    }
+    const previewRows = buildPreviewRows(issues, skipSet);
+    const toCreate = toCreateNew;
+    const fullPreviewText = buildPreviewText(previewRows);
+    const previewSummary = buildPreviewSummary(previewRows, toCreate.length, skipSet.size, alreadyOnRedmine.length, parsed.featureTitle);
+    const projectName = projects.find((p) => String(p.id) === projectId)?.name;
+    const previewFormatOptions = {
+        project: projectId,
+        ...(projectName ? { projectName } : {}),
+        status,
+        priority,
+        ...(parsed.featureTitle ? { featureTitle: parsed.featureTitle } : {}),
+    };
+    const activeStories = previewRows.filter((r) => r.level === "userStory" && !r.skipped);
+    const previewOverview = buildPreviewOverview(previewRows, previewFormatOptions, {
+        toCreateCount: toCreate.length,
+        newStories: activeStories.filter((r) => !r.onRedmine).length,
+        newTasks: previewRows.filter((r) => r.level === "subtask" && !r.skipped && !r.onRedmine).length,
+        alreadyOnRedmine: alreadyOnRedmine.length,
+        skipped: skipSet.size,
+    });
+    const previewDiagram = buildPreviewMermaidDiagram(previewRows, previewFormatOptions);
+    const previewTree = buildPreviewTree(previewRows, previewFormatOptions);
+    const previewIsLong = isPreviewLong(fullPreviewText, toCreate.length);
+    const previewDataBase = {
+        project: projectId,
+        status,
+        priority,
+        format: parsed.format,
+        featureTitle: parsed.featureTitle ?? null,
+        ...(loaded.sheetSource ? { sheetSource: loaded.sheetSource } : {}),
+        scopeNotes: parsed.scopeNotes,
+        parseWarnings: parsed.parseWarnings,
+        previewSummary,
+        previewOverview,
+        previewDiagram,
+        previewTree,
+        previewText: fullPreviewText,
+        previewIsLong,
+        previewRows,
+        issueCount: toCreate.length,
+        alreadyOnRedmineCount: alreadyOnRedmine.length,
+        skippedCount: skipSet.size,
+        trackerMapping: getTrackerMapping(),
+        trackerOptions: enumerationOptions(config.trackers),
+        trackerAliases: config.trackerAliases,
+        stepsToReproduceTrackers: [...STEPS_TO_REPRODUCE_TRACKER_NAMES],
+        stepsToReproduceRule: STEPS_TO_REPRODUCE_RULE,
+    };
+    if (input.previewAction === "cancel") {
+        return {
+            success: false,
+            error: "Batch issue creation cancelled by user",
+            data: { step: "cancelled", ...previewDataBase },
+        };
+    }
+    const wantsUpload = input.confirmSave === "yes" || input.previewAction === "proceed";
+    if (toCreate.length === 0) {
+        return {
+            success: true,
+            data: {
+                uploaded: false,
+                message: "Nothing to create — all rows already on Redmine (Task ID) or linked via existingNodeIds.",
+                ...previewDataBase,
+                alreadyOnRedmine: alreadyOnRedmine.map((i) => ({
+                    nodeId: i.nodeId,
+                    rowIndex: i.rowIndex,
+                    level: i.level,
+                    issueId: i.existingRedmineId,
+                    subject: i.subject,
+                })),
+            },
+        };
+    }
+    if (!wantsUpload) {
+        if (input.previewAction === "show_preview") {
+            return {
+                success: false,
+                needsInput: true,
+                question: {
+                    field: "previewAction",
+                    question: `Full preview (${toCreate.length} issues). Proceed to post to Redmine or cancel?`,
+                    options: ["proceed", "cancel"],
+                },
+                data: {
+                    step: "full_preview",
+                    batchMode: false,
+                    ...previewDataBase,
+                    hint: "STOP: User must confirm in chat. AskQuestion proceed | cancel only. Do NOT set previewAction: proceed until they choose proceed.",
+                },
+            };
+        }
+        const shortPreviewIntro = previewIsLong
+            ? `Batch preview ready (${toCreate.length} issues). Summary below — choose an action.`
+            : `Batch preview (${toCreate.length} issues):`;
+        return {
+            success: false,
+            needsInput: true,
+            question: {
+                field: "previewAction",
+                question: previewIsLong
+                    ? `${shortPreviewIntro}\n\n${previewSummary}\n\nShow full line-by-line preview, post to Redmine, or cancel?`
+                    : `${shortPreviewIntro}\n\n${previewSummary}\n\n${fullPreviewText}\n\nPost to Redmine or cancel?`,
+                options: previewIsLong
+                    ? ["show_preview", "proceed", "cancel"]
+                    : ["proceed", "cancel"],
+            },
+            data: {
+                step: "preview_gate",
+                batchMode: false,
+                ...previewDataBase,
+                hint: "STOP: Post in chat in order: (1) data.previewOverview, (2) data.previewDiagram as mermaid, (3) data.previewTree. Then AskQuestion yes/no. Do NOT set previewAction: proceed on this call.",
+            },
+        };
+    }
+    if (input.confirmSave === "no") {
+        return {
+            success: false,
+            error: "Batch issue creation cancelled by user",
+            data: { step: "cancelled", ...previewDataBase },
+        };
+    }
+    if (!projectId) {
+        return {
+            success: false,
+            error: "Project is required before upload",
+        };
+    }
+    const createdByNodeId = new Map();
+    const ordered = sortIssuesForUpload(issues.filter((i) => !skipSet.has(i.nodeId)));
+    for (const issue of ordered) {
+        if (issue.existingRedmineId !== undefined) {
+            createdByNodeId.set(issue.nodeId, issue.existingRedmineId);
+        }
+    }
+    const created = [];
+    const failed = [];
+    const allWarnings = [...parsed.parseWarnings];
+    for (const issue of toCreate) {
+        let parentIssueId;
+        if (issue.parentNodeId) {
+            parentIssueId = createdByNodeId.get(issue.parentNodeId);
+            if (!parentIssueId) {
+                failed.push({
+                    nodeId: issue.nodeId,
+                    rowIndex: issue.rowIndex,
+                    error: `Parent ${issue.parentNodeId} was not created (missing or failed earlier)`,
+                });
+                continue;
+            }
+        }
+        const result = await createRedmineIssueFromBatch({
+            projectId,
+            ...(issue.trackerId !== undefined
+                ? { trackerId: issue.trackerId }
+                : { trackerName: issue.tracker }),
+            subject: issue.subject,
+            ...(issue.description ? { description: issue.description } : {}),
+            ...(issue.comments ? { comments: issue.comments } : {}),
+            statusName: issue.status ?? status,
+            ...(issue.priorityId !== undefined
+                ? {
+                    priorityId: issue.priorityId,
+                    priorityName: issue.priority ?? priority,
+                }
+                : { priorityName: issue.priority ?? priority }),
+            ...(issue.assignedTo ? { assignedTo: issue.assignedTo } : {}),
+            ...(issue.targetVersion
+                ? { targetVersion: issue.targetVersion }
+                : {}),
+            ...(parentIssueId !== undefined ? { parentIssueId } : {}),
+            ...(issue.estimatedHours !== undefined
+                ? { estimatedHours: issue.estimatedHours }
+                : {}),
+        });
+        if (!result.success) {
+            failed.push({
+                nodeId: issue.nodeId,
+                rowIndex: issue.rowIndex,
+                error: result.error,
+            });
+            continue;
+        }
+        createdByNodeId.set(issue.nodeId, result.issueId);
+        allWarnings.push(...result.warnings);
+        created.push({
+            nodeId: issue.nodeId,
+            rowIndex: issue.rowIndex,
+            issueId: result.issueId,
+            issueUrl: result.issueUrl,
+            subject: issue.subject,
+            tracker: result.actualTracker?.name ?? issue.tracker,
+            level: issue.level,
+        });
+    }
+    const headerRow = rawSheet.rows.find((r) => r.sheetRow === parsed.headerRowIndex)?.cells ??
+        [];
+    const idColumn = resolveTaskIdColumnForWriteBack(headerRow, parsed.sheetColumns);
+    const compositeTicketColumn = parsed.sheetColumns !== undefined &&
+        usesCompositeTicketColumn(parsed.sheetColumns);
+    const featureCreated = created.find((entry) => entry.level === "feature");
+    const sheetMatrix = rawSheet.rows.map((row) => row.cells);
+    const featureWriteBack = featureCreated && parsed.featureTitle
+        ? (() => {
+            const headerRow0 = parsed.headerRowIndex - 1;
+            const featureRow = sheetMatrix[featureCreated.rowIndex - 1] ?? [];
+            const titleCol = findFeatureTitleColumnIndex(featureRow);
+            const columnIndex = titleCol >= 0 ? titleCol : 0;
+            return {
+                required: true,
+                rowIndex: featureCreated.rowIndex,
+                columnIndex,
+                columnLetter: columnIndexToLetter(columnIndex),
+                issueId: featureCreated.issueId,
+                issueUrl: featureCreated.issueUrl,
+                title: parsed.featureTitle,
+                formulaTemplate: '=HYPERLINK("{issueUrl}","Feature: {title} #{issueId}")',
+                hint: "MANDATORY Step 9b: write Feature HYPERLINK in the feature title cell (optional title row above header — not a mapped column). Do this before Ticket/MainTicket write-back.",
+            };
+        })()
+        : undefined;
+    const writeBackHints = loaded.sheetSource && parsed.sheetColumns
+        ? {
+            sheetSource: loaded.sheetSource,
+            headerRowIndex: parsed.headerRowIndex,
+            idColumnIndex: idColumn.columnIndex,
+            idColumnLetter: columnIndexToLetter(idColumn.columnIndex),
+            appendColumnIfMissing: idColumn.createdColumn,
+            idColumnHeader: TASK_ID_COLUMN_HEADER,
+            compositeTicketColumn,
+            formulaTemplate: compositeTicketColumn
+                ? '=HYPERLINK("{issueUrl}","Ticket:#{issueId}") for tasks; =HYPERLINK("{issueUrl}","MainTicket:#{issueId}") for user stories; same row: =HYPERLINK(url1,"Ticket:#id") & " " & HYPERLINK(url2,"MainTicket:#id") (Ticket first)'
+                : '=HYPERLINK("{issueUrl}","#{issueId}")',
+            unmergeBeforeWriteBack: true,
+            unmergeHint: "Step 9a: get_sheet_data(include_grid_data:true) → batch_update unmergeCells on id column (idColumnIndex) from first data row through max(created.rowIndex). Then batch_update_cells.",
+            levelPriority: ["subtask", "userStory", "feature"],
+            ticketCellRule: "Ticket label = Task · MainTicket label = User Story · same row: Ticket:… MainTicket:…",
+            ...(featureWriteBack ? { featureWriteBack } : {}),
+        }
+        : undefined;
+    return {
+        success: failed.length === 0,
+        ...(failed.length > 0
+            ? {
+                error: `${failed.length} issue(s) failed; ${created.length} created`,
+            }
+            : {}),
+        data: {
+            uploaded: true,
+            project: projectId,
+            created,
+            alreadyOnRedmine: alreadyOnRedmine.map((i) => ({
+                nodeId: i.nodeId,
+                rowIndex: i.rowIndex,
+                level: i.level,
+                issueId: i.existingRedmineId,
+                subject: i.subject,
+            })),
+            failed,
+            skipped: [...skipSet],
+            ...(writeBackHints ? { writeBackHints } : {}),
+            warnings: allWarnings,
+            format: parsed.format,
+            trackerMapping: getTrackerMapping(),
+        },
+    };
+}
+function getTrackerMapping() {
+    return {
+        featureRow: 'Title row "Feature: …" above header → Redmine Feature (parent of all stories)',
+        userStoryColumn: "userStory column → User Story under Feature; first line = subject, rest = description",
+        subtaskColumn: "subtask column → Task (or Type override e.g. Bug) under User Story",
+        descriptionColumn: "description column → task body when subtask present",
+        hoursColumn: "estimated_hours on User Story or subtask row",
+        targetVersionColumn: "fixed_version on User Story (applies until next story row)",
+        assignedToColumn: "assigned_to on subtask rows (blank if empty)",
+        sheetTypeColumn: "Type column → resolved via live Redmine config trackers + trackerAliases (e.g. Bug, CR→Change Request); preview/upload use id — name from config",
+        stepsToReproduceColumn: "Bug/Task only — derived from mapped roles (see stepsToReproduceRule): comments → description → issue subject → \"...\". Not a sheet column.",
+        taskIdColumn: "Task ID: single HYPERLINK (#id). Ticket column: Ticket:#id (Task), MainTicket:#id (User Story); same-row story+task → both labels; task-only rows → Ticket:#id only",
+        commentsColumn: "appended to issue description",
+        googleSheet: "sheetSource from redmine_agent_sheet_to_csv: agent writes Task ID HYPERLINKs via Google Sheets MCP (see batch skill Step 7)",
+        columnMapping: "Agent maps sheet headers to roles via columnMapping — no layout-specific parser",
+    };
+}
+//# sourceMappingURL=batchCreateIssuesWorkflow.js.map