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

package/dist/spreadsheet/batchColumnMapping.js

@@ -0,0 +1,660 @@
+import { BATCH_TRACKER_BY_LEVEL, FEATURE_ROOT_NODE_ID, } from "./batchCreationTypes.js";
+import { appendCommentsToDescription, parseHours, splitSubjectAndDescription, } from "./csvUtils.js";
+import { isAggregatingSheetRow, hoursForSubtaskOnRow, hoursForUserStoryOnRow, } from "./batchSheetHeuristics.js";
+import { findFeatureSheetRow, readFeatureRowExistingIdFromSheet, } from "./featureRow.js";
+import { buildSheetWriteBackTarget, readExistingRedmineIdFromRow, } from "./sheetColumnMap.js";
+import { normalizeSheetPriority, trackerForSheetRow, } from "./sheetRedmineFields.js";
+import { STEPS_TO_REPRODUCE_TRACKER_NAMES } from "../services/redmineConfig.js";
+/**
+ * Steps to Reproduce is never its own sheet column. Workflow derives it from mapped roles.
+ * Returned on map_columns / confirm_mapping so the agent does not invent a column.
+ */
+export const STEPS_TO_REPRODUCE_RULE = {
+    notASheetColumn: true,
+    doNotMapSeparateColumn: true,
+    appliesToTrackers: [...STEPS_TO_REPRODUCE_TRACKER_NAMES],
+    valuePriority: [
+        {
+            priority: 1,
+            source: "comments",
+            role: "comments",
+            label: "comments role (e.g. Comments / Question, RT Comment)",
+        },
+        {
+            priority: 2,
+            source: "description",
+            role: "description",
+            label: "description role (Description column when present)",
+        },
+        {
+            priority: 3,
+            source: "issueSubject",
+            roles: ["subtask", "userStory"],
+            label: "issue subject — first line of subtask cell, else userStory cell",
+        },
+        { priority: 4, source: "fallback", label: '"..."' },
+    ],
+    summary: "Map comments and description roles when headers exist. Bug/Task Steps to Reproduce is filled automatically from those mapped values, then issue subject — never map a dedicated Steps to Reproduce column.",
+};
+export const BATCH_COLUMN_FIELD_SCHEMA = [
+    {
+        role: "userStory",
+        required: true,
+        redmineUse: "User Story subject (User Stories, Task, or User Story column); first line = subject, rest = description",
+    },
+    {
+        role: "subtask",
+        required: true,
+        redmineUse: "Task subject (Tasks, Sub-Tasks, or Sub Task column) under current User Story",
+    },
+    {
+        role: "description",
+        required: false,
+        redmineUse: "Task description body (when Sub-Tasks present); Steps to Reproduce priority 2 (Bug/Task) when comments empty",
+        stepsToReproducePriority: 2,
+    },
+    {
+        role: "hours",
+        required: false,
+        redmineUse: "estimated_hours on Task; on story-only rows, on User Story",
+    },
+    {
+        role: "targetVersion",
+        required: false,
+        redmineUse: "fixed_version on User Story (applies until next story row)",
+    },
+    {
+        role: "assignedTo",
+        required: false,
+        redmineUse: "assigned_to on Task rows only",
+    },
+    {
+        role: "comments",
+        required: false,
+        redmineUse: "Appended to issue description; Steps to Reproduce priority 1 (Bug/Task) when non-empty",
+        stepsToReproducePriority: 1,
+    },
+    {
+        role: "redmineId",
+        required: false,
+        redmineUse: "Existing issue id — skip create; write-back after upload",
+    },
+    {
+        role: "ticket",
+        required: false,
+        redmineUse: "Ticket:#id (Task) and MainTicket:#id (User Story) in one column; Task-only rows use Ticket:#id",
+    },
+    {
+        role: "system",
+        required: false,
+        redmineUse: "Optional project hint (e.g. FE/BE)",
+    },
+    {
+        role: "status",
+        required: false,
+        redmineUse: "Optional override (usually workflow default New)",
+    },
+    {
+        role: "priority",
+        required: false,
+        redmineUse: "Optional override (usually Normal)",
+    },
+    {
+        role: "sheetType",
+        required: false,
+        redmineUse: "Redmine tracker (Type column), e.g. Bug, CR → Change Request",
+    },
+];
+const REQUIRED_COLUMN_ROLES = ["userStory", "subtask"];
+const ROLE_QUESTION_LABEL = {
+    userStory: "User Story (User Stories / Task column)",
+    subtask: "Task (Tasks / Sub-Tasks column under each story)",
+    description: "Description (task body when Sub-Tasks present)",
+    hours: "Hours (estimated hours)",
+    targetVersion: "Target Version (fixed version on User Story)",
+    assignedTo: "Assignee (on Task rows)",
+    comments: "Comments (appended to description)",
+    redmineId: "Task ID / existing Redmine link column",
+    ticket: "Ticket (Ticket:#id = Task, MainTicket:#id = User Story)",
+    system: "System (optional project hint)",
+    status: "Status override",
+    priority: "Priority override",
+    sheetType: "Type (tracker override, e.g. Bug)",
+};
+const OPTIONAL_UNMAPPED = "(leave unmapped)";
+function resolveColumnIndexDetailed(headers, spec) {
+    if (spec === undefined) {
+        return { ok: false, reason: "missing_spec" };
+    }
+    if (typeof spec === "number") {
+        if (spec < 0 || spec >= headers.length) {
+            return { ok: false, reason: "out_of_range" };
+        }
+        return { ok: true, index: spec };
+    }
+    const key = spec.trim().toLowerCase();
+    if (!key)
+        return { ok: false, reason: "missing_spec" };
+    const exactMatches = [];
+    for (let i = 0; i < headers.length; i++) {
+        const h = headers[i]?.trim() ?? "";
+        if (!h)
+            continue;
+        if (h.toLowerCase() === key)
+            exactMatches.push(i);
+    }
+    if (exactMatches.length === 1) {
+        return { ok: true, index: exactMatches[0] };
+    }
+    if (exactMatches.length > 1) {
+        return {
+            ok: false,
+            reason: "ambiguous",
+            matches: exactMatches.map((i) => headers[i] ?? "").filter(Boolean),
+        };
+    }
+    return { ok: false, reason: "not_found" };
+}
+function resolveColumnIndex(headers, spec) {
+    const result = resolveColumnIndexDetailed(headers, spec);
+    return result.ok ? result.index : -1;
+}
+function mappedColumnLabel(mapping, headers, role) {
+    const spec = mapping.columns[role];
+    if (spec === undefined)
+        return "(unmapped)";
+    const idx = resolveColumnIndex(headers, spec);
+    if (idx < 0)
+        return String(spec);
+    return headers[idx]?.trim() || `col ${idx}`;
+}
+const REDMINE_ID_HEADER_PATTERNS = new Set([
+    "task id",
+    "taskid",
+    "task_id",
+    "redmine id",
+    "redmine #",
+    "issue id",
+    "issue #",
+    "#",
+]);
+function normalizeHeaderLabel(header) {
+    return header.trim().toLowerCase();
+}
+function isRedmineIdHeader(normalized) {
+    return REDMINE_ID_HEADER_PATTERNS.has(normalized);
+}
+const OPTIONAL_COLUMN_ROLES = [
+    "description",
+    "hours",
+    "targetVersion",
+    "assignedTo",
+    "comments",
+    "redmineId",
+    "ticket",
+    "system",
+    "status",
+    "sheetType",
+    "priority",
+];
+/**
+ * Derive column roles from detected headers (MCP — agent uses this, no repo file search).
+ * Recognizes User Stories + Tasks layout as well as Task + Sub-Tasks.
+ */
+export function suggestColumnMappingFromHeaders(headers, headerRowIndex) {
+    const normalized = headers.map((h) => normalizeHeaderLabel(h ?? ""));
+    const columns = {};
+    const suggestedColumnIndices = {};
+    const usedIndices = new Set();
+    const ambiguousRoles = [];
+    function findIndices(predicate) {
+        const matches = [];
+        for (let i = 0; i < normalized.length; i++) {
+            const n = normalized[i] ?? "";
+            if (!n || usedIndices.has(i))
+                continue;
+            if (predicate(n, i))
+                matches.push(i);
+        }
+        return matches;
+    }
+    function assignRole(role, indices) {
+        if (indices.length === 0)
+            return false;
+        if (indices.length > 1) {
+            ambiguousRoles.push(role);
+            return false;
+        }
+        const index = indices[0];
+        const label = headers[index]?.trim();
+        if (!label)
+            return false;
+        columns[role] = label;
+        suggestedColumnIndices[role] = index;
+        usedIndices.add(index);
+        return true;
+    }
+    assignRole("userStory", findIndices((n) => n === "user stories" || n === "user story" || n === "story").length > 0
+        ? findIndices((n) => n === "user stories" || n === "user story" || n === "story")
+        : findIndices((n) => n === "task" &&
+            !n.includes("sub") &&
+            !isRedmineIdHeader(n)));
+    assignRole("subtask", findIndices((n) => n.includes("sub") &&
+        (n.includes("task") || n.includes("tasks"))).length > 0
+        ? findIndices((n) => n.includes("sub") &&
+            (n.includes("task") || n.includes("tasks")))
+        : findIndices((n) => n === "tasks"));
+    assignRole("description", findIndices((n) => n === "description" || n.includes("description")));
+    assignRole("hours", findIndices((n) => n === "hours" || n === "eta" || n === "estimate"));
+    assignRole("targetVersion", findIndices((n) => n === "target version" || n === "version" || n === "sprint"));
+    assignRole("assignedTo", findIndices((n) => n === "assigned to" || n === "assignee" || n.includes("assignee")));
+    assignRole("comments", findIndices((n) => n.includes("comment") || n.includes("question")));
+    assignRole("redmineId", findIndices((n) => isRedmineIdHeader(n)));
+    if (!columns.redmineId) {
+        assignRole("ticket", findIndices((n) => n === "ticket"));
+    }
+    assignRole("system", findIndices((n) => n === "system" || n.includes("fe/be")));
+    assignRole("status", findIndices((n) => n === "status"));
+    assignRole("sheetType", findIndices((n) => n === "type" || n === "tracker"));
+    assignRole("priority", findIndices((n) => n === "priority"));
+    const mappedRoles = new Set(Object.keys(columns));
+    const unmappedOptionalRoles = OPTIONAL_COLUMN_ROLES.filter((role) => !mappedRoles.has(role));
+    if (!columns.userStory)
+        ambiguousRoles.push("userStory");
+    if (!columns.subtask)
+        ambiguousRoles.push("subtask");
+    return {
+        headerRowIndex,
+        columns,
+        suggestedColumnIndices,
+        unmappedOptionalRoles,
+        ambiguousRoles: [...new Set(ambiguousRoles)],
+    };
+}
+/** Resolved Steps to Reproduce sources for a concrete columnMapping (MCP + mapping preview). */
+export function buildStepsToReproduceMappingSection(mapping, headers) {
+    const lines = [
+        "",
+        "STEPS TO REPRODUCE (Bug + Task — derived from mapped roles, NOT a sheet column)",
+        "  Do not map a separate column. Workflow fills the Redmine custom field automatically.",
+        "",
+        `  1. comments role     → ${mappedColumnLabel(mapping, headers, "comments")}`,
+        `  2. description role  → ${mappedColumnLabel(mapping, headers, "description")}`,
+        `  3. issue subject     → subtask "${mappedColumnLabel(mapping, headers, "subtask")}" or userStory "${mappedColumnLabel(mapping, headers, "userStory")}"`,
+        '  4. fallback          → "..."',
+    ];
+    return lines.join("\n");
+}
+/** Validate agent columnMapping before building the issue tree. */
+export function validateColumnMapping(raw, mapping) {
+    const problems = [];
+    const headerRowIndex = mapping.headerRowIndex;
+    if (headerRowIndex < 0 || headerRowIndex >= raw.rows.length) {
+        problems.push({
+            role: "userStory",
+            issue: `headerRowIndex ${headerRowIndex} is outside the sheet (${raw.rows.length} row(s)).`,
+        });
+        return {
+            valid: false,
+            problems,
+            detectedHeaders: [],
+            headerRowIndex,
+        };
+    }
+    const headerRow = raw.rows[headerRowIndex]?.cells ?? [];
+    const detectedHeaders = headerRow.map((h) => h.trim());
+    if (detectedHeaders.filter(Boolean).length === 0) {
+        problems.push({
+            role: "userStory",
+            issue: `Header row ${headerRowIndex + 1} has no column labels.`,
+        });
+        return { valid: false, problems, detectedHeaders, headerRowIndex };
+    }
+    const resolved = new Map();
+    for (const [role, spec] of Object.entries(mapping.columns)) {
+        if (spec === undefined)
+            continue;
+        const result = resolveColumnIndexDetailed(detectedHeaders, spec);
+        if (!result.ok) {
+            const label = ROLE_QUESTION_LABEL[role] ?? role;
+            if (result.reason === "missing_spec") {
+                problems.push({ role, issue: `${label}: no column specified.` });
+            }
+            else if (result.reason === "not_found") {
+                problems.push({
+                    role,
+                    issue: `${label}: column "${String(spec)}" not found in headers.`,
+                    spec,
+                });
+            }
+            else if (result.reason === "out_of_range") {
+                problems.push({
+                    role,
+                    issue: `${label}: column index ${String(spec)} is out of range (0–${detectedHeaders.length - 1}).`,
+                    spec,
+                });
+            }
+            else if (result.reason === "ambiguous") {
+                problems.push({
+                    role,
+                    issue: `${label}: "${String(spec)}" matches multiple headers: ${(result.matches ?? []).join(", ")}.`,
+                    spec,
+                });
+            }
+            continue;
+        }
+        resolved.set(role, result.index);
+    }
+    for (const role of REQUIRED_COLUMN_ROLES) {
+        if (!mapping.columns[role]) {
+            problems.push({
+                role,
+                issue: `${ROLE_QUESTION_LABEL[role]} is required but not mapped.`,
+            });
+            continue;
+        }
+        if (!resolved.has(role)) {
+            continue;
+        }
+    }
+    const userStoryIdx = resolved.get("userStory");
+    const subtaskIdx = resolved.get("subtask");
+    if (userStoryIdx !== undefined &&
+        subtaskIdx !== undefined &&
+        userStoryIdx === subtaskIdx) {
+        problems.push({
+            role: "subtask",
+            issue: "User Story and Sub-Task cannot use the same column.",
+        });
+    }
+    const seen = new Map();
+    for (const [role, index] of resolved) {
+        const other = seen.get(index);
+        if (other && other !== role) {
+            problems.push({
+                role,
+                issue: `Column "${detectedHeaders[index]}" is mapped to both ${other} and ${role}.`,
+            });
+        }
+        seen.set(index, role);
+    }
+    return {
+        valid: problems.length === 0,
+        problems,
+        detectedHeaders: detectedHeaders.filter(Boolean),
+        headerRowIndex,
+    };
+}
+/** AskQuestion prompts for map_columns / fix_column_mapping steps. */
+export function buildColumnMappingQuestions(validation, options) {
+    const headerOptions = validation.detectedHeaders.filter(Boolean);
+    const rolesNeeded = new Set();
+    for (const problem of validation.problems) {
+        rolesNeeded.add(problem.role);
+    }
+    if (rolesNeeded.size === 0 && options?.includeOptional) {
+        for (const field of BATCH_COLUMN_FIELD_SCHEMA) {
+            if (field.required)
+                rolesNeeded.add(field.role);
+        }
+    }
+    const questions = [];
+    for (const role of rolesNeeded) {
+        const schema = BATCH_COLUMN_FIELD_SCHEMA.find((f) => f.role === role);
+        const required = schema?.required ?? REQUIRED_COLUMN_ROLES.includes(role);
+        const problem = validation.problems.find((p) => p.role === role);
+        const label = ROLE_QUESTION_LABEL[role] ?? role;
+        const roleOptions = required
+            ? [...headerOptions]
+            : [...headerOptions, OPTIONAL_UNMAPPED];
+        questions.push({
+            id: `column-${role}`,
+            field: `columnMapping.columns.${role}`,
+            question: problem
+                ? `${label} — ${problem.issue} Pick the correct sheet column.`
+                : `${label} — which sheet column? ${schema?.redmineUse ?? ""}`.trim(),
+            options: roleOptions.length > 0 ? roleOptions : headerOptions,
+        });
+    }
+    return questions;
+}
+/** Human-readable table of agent columnMapping for confirm_mapping step. */
+export function buildMappingPreview(mapping, headers) {
+    const lines = [
+        "══════════════════════════════════════════════════════════════",
+        "  COLUMN MAPPING — review before parsing (confirm or change)",
+        "══════════════════════════════════════════════════════════════",
+        "",
+        `Header row: sheet line ${mapping.headerRowIndex + 1} (0-based index ${mapping.headerRowIndex})`,
+        "",
+        "Detected headers:",
+        headers.map((h, i) => `  [${i}] ${h.trim() || "(empty)"}`).join("\n"),
+        "",
+        "Role          │ Sheet column",
+        "──────────────┼────────────────────────────",
+    ];
+    for (const field of BATCH_COLUMN_FIELD_SCHEMA) {
+        const spec = mapping.columns[field.role];
+        if (spec === undefined) {
+            if (field.required) {
+                lines.push(`${field.role.padEnd(13)} │ **MISSING (required)**`);
+            }
+            else {
+                lines.push(`${field.role.padEnd(13)} │ (unmapped)`);
+            }
+            continue;
+        }
+        const idx = resolveColumnIndex(headers, spec);
+        const label = idx >= 0 ? headers[idx]?.trim() || `col ${idx}` : String(spec);
+        const mark = field.required ? " *" : "";
+        lines.push(`${field.role.padEnd(13)} │ ${label}${mark}`);
+    }
+    lines.push("");
+    lines.push("* = required. Optional roles may stay unmapped.");
+    lines.push(buildStepsToReproduceMappingSection(mapping, headers));
+    return lines.join("\n");
+}
+export function columnMappingToSheetMap(headers, mapping) {
+    const cols = mapping.columns;
+    const idx = (role) => resolveColumnIndex(headers, cols[role]);
+    return {
+        ticket: idx("ticket"),
+        userStory: idx("userStory"),
+        subtask: idx("subtask"),
+        description: idx("description"),
+        hours: idx("hours"),
+        targetVersion: idx("targetVersion"),
+        assignedTo: idx("assignedTo"),
+        comments: idx("comments"),
+        redmineId: idx("redmineId"),
+        system: idx("system"),
+        status: idx("status"),
+        sheetType: idx("sheetType"),
+        priority: idx("priority"),
+    };
+}
+function cell(row, index) {
+    if (index < 0)
+        return "";
+    return (row[index] ?? "").trim();
+}
+function buildIssue(params) {
+    if (!params.subject.trim())
+        return null;
+    const issue = {
+        nodeId: `row-${params.rowIndex}-${params.level}`,
+        rowIndex: params.rowIndex,
+        level: params.level,
+        tracker: trackerForSheetRow(params.sheetType ?? "", params.level),
+        subject: params.subject.trim(),
+        description: appendCommentsToDescription(params.description, params.comments),
+        ...(params.comments.trim()
+            ? { comments: params.comments.trim() }
+            : {}),
+        targetVersion: params.targetVersion.trim(),
+        assignedTo: params.assignedTo.trim(),
+        system: params.system?.trim() ?? "",
+        parentNodeId: params.parentNodeId,
+        ...(params.sheetType?.trim()
+            ? { sheetType: params.sheetType.trim() }
+            : {}),
+    };
+    if (params.hours !== undefined)
+        issue.estimatedHours = params.hours;
+    if (params.existingRedmineId !== undefined) {
+        issue.existingRedmineId = params.existingRedmineId;
+    }
+    const priority = normalizeSheetPriority(params.sheetPriority ?? "");
+    if (priority)
+        issue.priority = priority;
+    return issue;
+}
+export function parseBatchWithColumnMapping(raw, mapping) {
+    const parseWarnings = [];
+    const headerRowIndex = mapping.headerRowIndex;
+    const headerRow = raw.rows[headerRowIndex]?.cells ?? [];
+    const cols = columnMappingToSheetMap(headerRow, mapping);
+    const sheetWriteBack = buildSheetWriteBackTarget(cols);
+    const featureTitle = raw.featureTitle;
+    const issues = [];
+    if (cols.userStory < 0 || cols.subtask < 0) {
+        return {
+            format: "mapped",
+            scopeNotes: "",
+            headerRowIndex: headerRowIndex + 1,
+            issues: [],
+            parseWarnings: [
+                "columnMapping must include userStory and subtask columns.",
+            ],
+        };
+    }
+    if (featureTitle) {
+        const matrix = raw.rows.map((r) => r.cells);
+        const featureSheetRow = findFeatureSheetRow(matrix, headerRowIndex);
+        const existingFeatureId = readFeatureRowExistingIdFromSheet(matrix, featureSheetRow, cols.redmineId);
+        const featureNode = buildIssue({
+            rowIndex: featureSheetRow,
+            level: "feature",
+            subject: featureTitle,
+            description: "",
+            targetVersion: "",
+            assignedTo: "",
+            comments: "",
+            parentNodeId: null,
+            ...(existingFeatureId !== undefined
+                ? { existingRedmineId: existingFeatureId }
+                : {}),
+        });
+        if (featureNode) {
+            featureNode.nodeId = FEATURE_ROOT_NODE_ID;
+            issues.push(featureNode);
+        }
+    }
+    let currentUserStoryNodeId = null;
+    const featureParentId = featureTitle ? FEATURE_ROOT_NODE_ID : null;
+    let currentTargetVersion = "";
+    for (let i = headerRowIndex + 1; i < raw.rows.length; i++) {
+        const row = raw.rows[i]?.cells ?? [];
+        const sheetRow = raw.rows[i]?.sheetRow ?? i + 1;
+        const taskCell = cell(row, cols.userStory);
+        const subCell = cell(row, cols.subtask);
+        const descriptionCol = cell(row, cols.description);
+        const hoursCol = cols.hours >= 0 ? cell(row, cols.hours) : "";
+        const targetVersionCol = cols.targetVersion >= 0 ? cell(row, cols.targetVersion) : "";
+        const assignedToCol = cols.assignedTo >= 0 ? cell(row, cols.assignedTo) : "";
+        const commentsCol = cols.comments >= 0 ? cell(row, cols.comments) : "";
+        const sheetTypeCol = cols.sheetType >= 0 ? cell(row, cols.sheetType) : "";
+        const sheetPriorityCol = cols.priority >= 0 ? cell(row, cols.priority) : "";
+        const systemCol = cols.system >= 0 ? cell(row, cols.system) : "";
+        const storyRedmineId = readExistingRedmineIdFromRow(row, cols, "userStory");
+        if (!taskCell && !subCell)
+            continue;
+        if (isAggregatingSheetRow({ userStoryText: taskCell, subtaskText: subCell })) {
+            parseWarnings.push(`Row ${sheetRow}: Rollup/summary row skipped (not created on Redmine).`);
+            currentUserStoryNodeId = null;
+            continue;
+        }
+        if (taskCell) {
+            if (targetVersionCol)
+                currentTargetVersion = targetVersionCol;
+            const { subject, description: taskBody } = splitSubjectAndDescription(taskCell);
+            const storyHoursCell = hoursForUserStoryOnRow(subCell, hoursCol);
+            const hours = storyHoursCell ? parseHours(storyHoursCell) : undefined;
+            const subRowIdEarly = subCell !== ""
+                ? readExistingRedmineIdFromRow(row, cols, "subtask")
+                : undefined;
+            // Same-row subtask gets description/comments when it will be created.
+            // When subtask already exists on Redmine, attach row fields to User Story.
+            const subtaskWillBeCreated = subCell !== "" && subRowIdEarly === undefined;
+            const storyDescription = subCell && !subtaskWillBeCreated
+                ? descriptionCol.trim() || taskBody
+                : taskBody;
+            const storyComments = subCell && subtaskWillBeCreated ? "" : commentsCol;
+            const node = buildIssue({
+                rowIndex: sheetRow,
+                level: "userStory",
+                subject,
+                description: storyDescription,
+                ...(hours !== undefined ? { hours } : {}),
+                targetVersion: currentTargetVersion,
+                assignedTo: "",
+                comments: storyComments,
+                parentNodeId: featureParentId,
+                sheetType: sheetTypeCol,
+                sheetPriority: sheetPriorityCol,
+                system: systemCol,
+                ...(storyRedmineId !== undefined
+                    ? { existingRedmineId: storyRedmineId }
+                    : {}),
+            });
+            if (!node) {
+                parseWarnings.push(`Row ${sheetRow}: User Story has no subject.`);
+            }
+            else {
+                issues.push(node);
+                currentUserStoryNodeId = node.nodeId;
+            }
+        }
+        if (subCell) {
+            if (!currentUserStoryNodeId) {
+                parseWarnings.push(`Row ${sheetRow}: Sub-Task skipped — no User Story above.`);
+                continue;
+            }
+            const { subject } = splitSubjectAndDescription(subCell);
+            const subHoursCell = hoursForSubtaskOnRow(taskCell, hoursCol);
+            const hours = subHoursCell ? parseHours(subHoursCell) : undefined;
+            const subRowId = readExistingRedmineIdFromRow(row, cols, "subtask");
+            const node = buildIssue({
+                rowIndex: sheetRow,
+                level: "subtask",
+                subject,
+                description: descriptionCol,
+                ...(hours !== undefined ? { hours } : {}),
+                targetVersion: "",
+                assignedTo: assignedToCol,
+                comments: commentsCol,
+                parentNodeId: currentUserStoryNodeId,
+                sheetType: sheetTypeCol,
+                sheetPriority: sheetPriorityCol,
+                system: systemCol,
+                ...(subRowId !== undefined ? { existingRedmineId: subRowId } : {}),
+            });
+            if (!node) {
+                parseWarnings.push(`Row ${sheetRow}: Sub-Task has no subject.`);
+                continue;
+            }
+            issues.push(node);
+        }
+    }
+    return {
+        format: "mapped",
+        scopeNotes: featureTitle ? `Feature: ${featureTitle}` : "",
+        headerRowIndex: headerRowIndex + 1,
+        sheetColumns: cols,
+        ...(sheetWriteBack ? { sheetWriteBack } : {}),
+        ...(featureTitle ? { featureTitle } : {}),
+        issues,
+        parseWarnings,
+    };
+}
+//# sourceMappingURL=batchColumnMapping.js.map