@mcp-consultant-tools/azure-devops 27.0.0-beta.1 → 27.0.0-beta.10

package/build/sync/markdown-serializer.js

@@ -0,0 +1,646 @@
+/**
+ * Markdown Serialization Utilities
+ *
+ * Convert between ADO work items and local markdown files.
+ * Uses YAML frontmatter for metadata and markdown sections for content.
+ */
+import { isHtmlContent, getAdditionalFieldConfig, ADDITIONAL_FIELD_DISPLAY_NAMES } from './html-detection.js';
+/**
+ * Simple YAML serializer for frontmatter
+ * Handles basic types: string, number, boolean, arrays
+ */
+function serializeFrontmatter(data) {
+    const lines = ['---'];
+    for (const [key, value] of Object.entries(data)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                continue;
+            lines.push(`${key}:`);
+            for (const item of value) {
+                lines.push(`- ${item}`);
+            }
+        }
+        else if (typeof value === 'string') {
+            // Quote strings that might be parsed as other types or contain special chars
+            if (value.includes(':') || value.includes('#') || value.includes('\n') ||
+                value.match(/^[\d.]+$/) || value === 'true' || value === 'false' ||
+                value === 'null' || value === '') {
+                lines.push(`${key}: "${value.replace(/"/g, '\\"')}"`);
+            }
+            else {
+                lines.push(`${key}: ${value}`);
+            }
+        }
+        else if (typeof value === 'number' || typeof value === 'boolean') {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    lines.push('---');
+    return lines.join('\n');
+}
+/**
+ * Simple YAML parser for frontmatter
+ */
+function parseFrontmatter(yamlContent) {
+    const result = {};
+    const lines = yamlContent.split('\n');
+    let currentKey = null;
+    let currentArray = null;
+    for (const line of lines) {
+        // Skip empty lines
+        if (!line.trim())
+            continue;
+        // Array item
+        if (line.match(/^\s*-\s+/)) {
+            if (currentKey && currentArray !== null) {
+                const value = line.replace(/^\s*-\s+/, '').trim();
+                currentArray.push(parseYamlValue(value));
+            }
+            continue;
+        }
+        // Key-value pair
+        const match = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)?$/);
+        if (match) {
+            // Save previous array if any
+            if (currentKey && currentArray !== null) {
+                result[currentKey] = currentArray;
+            }
+            currentKey = match[1];
+            const rawValue = match[2]?.trim();
+            // Check if this is start of array (no value after colon)
+            if (!rawValue) {
+                currentArray = [];
+            }
+            else {
+                currentArray = null;
+                result[currentKey] = parseYamlValue(rawValue);
+            }
+        }
+    }
+    // Save final array if any
+    if (currentKey && currentArray !== null) {
+        result[currentKey] = currentArray;
+    }
+    return result;
+}
+/**
+ * Parse a YAML value string to appropriate type
+ */
+function parseYamlValue(value) {
+    // Remove quotes
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    // Boolean
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    // Null
+    if (value === 'null' || value === '~')
+        return null;
+    // Number
+    if (value.match(/^-?\d+$/))
+        return parseInt(value, 10);
+    if (value.match(/^-?\d+\.\d+$/))
+        return parseFloat(value);
+    return value;
+}
+/**
+ * Convert an ADO work item to markdown file content
+ *
+ * @param workItem - The work item from ADO API
+ * @param revision - The revision number
+ * @returns Object with markdown content and list of skipped fields (if any were HTML)
+ */
+export function workItemToMarkdown(workItem, revision) {
+    const fields = workItem.fields || {};
+    const fieldConfig = getAdditionalFieldConfig();
+    const skippedFields = [];
+    // Build frontmatter data
+    const frontmatter = {
+        id: workItem.id,
+        title: fields['System.Title'] || '',
+        type: fields['System.WorkItemType'] || 'Unknown',
+        state: fields['System.State'] || '',
+        url: workItem._links?.html?.href || `https://dev.azure.com/_workitems/edit/${workItem.id}`,
+    };
+    // Optional fields
+    if (fields['System.AssignedTo']?.displayName) {
+        frontmatter.assignedTo = fields['System.AssignedTo'].displayName;
+    }
+    if (fields['Microsoft.VSTS.Scheduling.StoryPoints'] !== undefined) {
+        frontmatter.storyPoints = fields['Microsoft.VSTS.Scheduling.StoryPoints'];
+    }
+    if (fields['System.Parent']) {
+        frontmatter.parent = fields['System.Parent'];
+    }
+    // MoSCoW priority (custom field - varies by org)
+    const moscowField = fields['Custom.MoSCoW'] || fields['Microsoft.VSTS.Common.Priority'];
+    if (moscowField) {
+        frontmatter.moscow = moscowField;
+    }
+    // Tags
+    if (fields['System.Tags']) {
+        frontmatter.tags = fields['System.Tags'].split(';').map((t) => t.trim()).filter((t) => t);
+    }
+    if (fields['System.AreaPath']) {
+        frontmatter.areaPath = fields['System.AreaPath'];
+    }
+    if (fields['System.IterationPath']) {
+        frontmatter.iterationPath = fields['System.IterationPath'];
+    }
+    // Sync metadata
+    frontmatter.lastSyncedRevision = revision;
+    frontmatter.lastSyncedAt = new Date().toISOString();
+    // Build content sections
+    const description = fields['System.Description'] || '';
+    const acceptanceCriteria = fields['Microsoft.VSTS.Common.AcceptanceCriteria'] || '';
+    let content = serializeFrontmatter(frontmatter);
+    content += '\n\n# Description\n\n';
+    content += description.trim() || '_No description provided._';
+    content += '\n\n---\n\n# Acceptance Criteria\n\n';
+    content += acceptanceCriteria.trim() || '_No acceptance criteria provided._';
+    // Add additional fields if present and in markdown format
+    const addOptionalSection = (fieldName, displayName, sectionTitle) => {
+        const fieldContent = fields[fieldName];
+        if (!fieldContent || !fieldContent.trim()) {
+            return; // Field not present, skip silently
+        }
+        if (isHtmlContent(fieldContent)) {
+            skippedFields.push(`${displayName} (HTML)`);
+            return; // HTML format, skip with warning
+        }
+        content += `\n\n---\n\n# ${sectionTitle}\n\n`;
+        content += fieldContent.trim();
+    };
+    addOptionalSection(fieldConfig.howToTest, ADDITIONAL_FIELD_DISPLAY_NAMES.howToTest, 'How to Test');
+    addOptionalSection(fieldConfig.predeploymentSteps, ADDITIONAL_FIELD_DISPLAY_NAMES.predeploymentSteps, 'Predeployment Steps');
+    addOptionalSection(fieldConfig.postdeploymentSteps, ADDITIONAL_FIELD_DISPLAY_NAMES.postdeploymentSteps, 'Postdeployment Steps');
+    addOptionalSection(fieldConfig.deploymentInformation, ADDITIONAL_FIELD_DISPLAY_NAMES.deploymentInformation, 'Deployment Information');
+    content += '\n';
+    return { content, skippedFields };
+}
+/**
+ * Parse a markdown file to extract frontmatter and content sections
+ */
+export function parseWorkItemMarkdown(content) {
+    // Extract frontmatter between ---
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        throw new Error('Invalid work item markdown file: missing YAML frontmatter');
+    }
+    const frontmatterRaw = frontmatterMatch[1];
+    const frontmatterData = parseFrontmatter(frontmatterRaw);
+    // Validate required fields
+    if (!frontmatterData.id || typeof frontmatterData.id !== 'number') {
+        throw new Error('Invalid work item markdown file: missing or invalid "id" in frontmatter');
+    }
+    const frontmatter = {
+        id: frontmatterData.id,
+        title: frontmatterData.title || '',
+        type: frontmatterData.type || 'Unknown',
+        state: frontmatterData.state || '',
+        url: frontmatterData.url || '',
+        assignedTo: frontmatterData.assignedTo,
+        storyPoints: frontmatterData.storyPoints,
+        parent: frontmatterData.parent,
+        moscow: frontmatterData.moscow,
+        tags: frontmatterData.tags,
+        areaPath: frontmatterData.areaPath,
+        iterationPath: frontmatterData.iterationPath,
+        lastSyncedRevision: frontmatterData.lastSyncedRevision || 0,
+        lastSyncedAt: frontmatterData.lastSyncedAt || '',
+    };
+    // Extract content after frontmatter
+    const contentAfterFrontmatter = content.slice(frontmatterMatch[0].length);
+    // Helper to extract a section by heading
+    // Looks for # SectionName and captures content until the next # heading or end of file
+    const extractSection = (sectionName) => {
+        // Match section heading followed by content, stopping at next section divider or heading
+        const regex = new RegExp(`#\\s+${escapeRegex(sectionName)}\\s*\\n([\\s\\S]*?)(?=\\n---\\n|\\n#\\s+|$)`, 'i');
+        const match = contentAfterFrontmatter.match(regex);
+        if (!match)
+            return undefined;
+        const sectionContent = match[1].trim();
+        // Return undefined if it's just the placeholder text
+        if (sectionContent === `_No ${sectionName.toLowerCase()} provided._`) {
+            return undefined;
+        }
+        return sectionContent || undefined;
+    };
+    // Extract primary sections
+    let description = extractSection('Description') || '';
+    if (description === '_No description provided._') {
+        description = '';
+    }
+    let acceptanceCriteria = extractSection('Acceptance Criteria') || '';
+    if (acceptanceCriteria === '_No acceptance criteria provided._') {
+        acceptanceCriteria = '';
+    }
+    // Extract additional fields (optional)
+    const additionalFields = {};
+    const howToTest = extractSection('How to Test');
+    if (howToTest)
+        additionalFields.howToTest = howToTest;
+    const predeploymentSteps = extractSection('Predeployment Steps');
+    if (predeploymentSteps)
+        additionalFields.predeploymentSteps = predeploymentSteps;
+    const postdeploymentSteps = extractSection('Postdeployment Steps');
+    if (postdeploymentSteps)
+        additionalFields.postdeploymentSteps = postdeploymentSteps;
+    const deploymentInformation = extractSection('Deployment Information');
+    if (deploymentInformation)
+        additionalFields.deploymentInformation = deploymentInformation;
+    return {
+        frontmatter,
+        description,
+        acceptanceCriteria,
+        additionalFields,
+        rawContent: content,
+    };
+}
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Convert ADO comments to a read-only markdown file
+ */
+export function commentsToMarkdown(workItem, comments) {
+    const fields = workItem.fields || {};
+    const frontmatter = {
+        id: workItem.id,
+        title: fields['System.Title'] || '',
+        commentCount: comments.length,
+        lastSyncedAt: new Date().toISOString(),
+    };
+    let content = serializeFrontmatter(frontmatter);
+    content += '\n\n# Comments\n\n';
+    content += '> **NOTE**: This file is read-only. Comments cannot be pushed back to ADO.\n\n';
+    if (comments.length === 0) {
+        content += '_No comments on this work item._\n';
+    }
+    else {
+        // Sort comments by date (oldest first)
+        const sortedComments = [...comments].sort((a, b) => {
+            const dateA = new Date(a.createdDate || a.publishedDate || 0);
+            const dateB = new Date(b.createdDate || b.publishedDate || 0);
+            return dateA.getTime() - dateB.getTime();
+        });
+        sortedComments.forEach((comment, index) => {
+            content += '---\n\n';
+            content += `## Comment #${index + 1}\n`;
+            content += `**Author**: ${comment.createdBy?.displayName || 'Unknown'}\n`;
+            content += `**Date**: ${comment.createdDate || comment.publishedDate || 'Unknown'}\n\n`;
+            content += `${comment.text || comment.content || ''}\n\n`;
+        });
+    }
+    return content;
+}
+/**
+ * Build ADO patch operations from parsed markdown changes
+ * Only updates fields that have actually changed.
+ * Auto-converts HTML fields to markdown format unless skipAutoConvert is true.
+ *
+ * @param parsed - Parsed work item file
+ * @param currentWorkItem - Current work item from ADO
+ * @param skipAutoConvert - Skip automatic HTML-to-markdown conversion (default: false)
+ */
+export function buildPatchOperations(parsed, currentWorkItem, skipAutoConvert = false) {
+    const operations = [];
+    const skippedFields = [];
+    const convertedFields = [];
+    const currentFields = currentWorkItem.fields || {};
+    const fieldConfig = getAdditionalFieldConfig();
+    // Check Title
+    const currentTitle = currentFields['System.Title'] || '';
+    if (parsed.frontmatter.title !== currentTitle) {
+        operations.push({
+            op: 'replace',
+            path: '/fields/System.Title',
+            value: parsed.frontmatter.title,
+        });
+    }
+    // Check Description - always try to set markdown format when writing
+    const currentDescription = currentFields['System.Description'] || '';
+    const descriptionIsHtml = isHtmlContent(currentDescription);
+    if (descriptionIsHtml && skipAutoConvert) {
+        // Skip HTML field when skipAutoConvert is true
+        skippedFields.push('Description (HTML in ADO - skipAutoConvert=true)');
+    }
+    else if (parsed.description !== currentDescription || descriptionIsHtml) {
+        // Write field value AND always try to set markdown format
+        operations.push({
+            op: currentDescription ? 'replace' : 'add',
+            path: '/fields/System.Description',
+            value: parsed.description,
+        });
+        // Always add format op - API silently ignores if not applicable
+        operations.push({
+            op: 'add',
+            path: '/multilineFieldsFormat/System.Description',
+            value: 'Markdown',
+        });
+        if (descriptionIsHtml) {
+            convertedFields.push('Description');
+        }
+    }
+    // Check Acceptance Criteria - always try to set markdown format when writing
+    const currentAC = currentFields['Microsoft.VSTS.Common.AcceptanceCriteria'] || '';
+    const acIsHtml = isHtmlContent(currentAC);
+    if (acIsHtml && skipAutoConvert) {
+        // Skip HTML field when skipAutoConvert is true
+        skippedFields.push('Acceptance Criteria (HTML in ADO - skipAutoConvert=true)');
+    }
+    else if (parsed.acceptanceCriteria !== currentAC || acIsHtml) {
+        // Write field value AND always try to set markdown format
+        operations.push({
+            op: currentAC ? 'replace' : 'add',
+            path: '/fields/Microsoft.VSTS.Common.AcceptanceCriteria',
+            value: parsed.acceptanceCriteria,
+        });
+        // Always add format op - API silently ignores if not applicable
+        operations.push({
+            op: 'add',
+            path: '/multilineFieldsFormat/Microsoft.VSTS.Common.AcceptanceCriteria',
+            value: 'Markdown',
+        });
+        if (acIsHtml) {
+            convertedFields.push('Acceptance Criteria');
+        }
+    }
+    // Helper to check and add patch operation for additional field
+    // Always tries to set markdown format when writing to a field
+    const checkAdditionalField = (localValue, fieldName, displayName) => {
+        const currentValue = currentFields[fieldName] || '';
+        const localContent = localValue || '';
+        const fieldIsHtml = currentValue && isHtmlContent(currentValue);
+        if (fieldIsHtml && skipAutoConvert) {
+            // Skip HTML field when skipAutoConvert is true
+            skippedFields.push(`${displayName} (HTML in ADO - skipAutoConvert=true)`);
+            return;
+        }
+        if (localContent !== currentValue || fieldIsHtml) {
+            // Write field value AND always try to set markdown format
+            operations.push({
+                op: currentValue ? 'replace' : 'add',
+                path: `/fields/${fieldName}`,
+                value: localContent,
+            });
+            // Always add format op - API silently ignores if not applicable
+            operations.push({
+                op: 'add',
+                path: `/multilineFieldsFormat/${fieldName}`,
+                value: 'Markdown',
+            });
+            if (fieldIsHtml) {
+                convertedFields.push(displayName);
+            }
+        }
+    };
+    // Check additional fields
+    checkAdditionalField(parsed.additionalFields.howToTest, fieldConfig.howToTest, ADDITIONAL_FIELD_DISPLAY_NAMES.howToTest);
+    checkAdditionalField(parsed.additionalFields.predeploymentSteps, fieldConfig.predeploymentSteps, ADDITIONAL_FIELD_DISPLAY_NAMES.predeploymentSteps);
+    checkAdditionalField(parsed.additionalFields.postdeploymentSteps, fieldConfig.postdeploymentSteps, ADDITIONAL_FIELD_DISPLAY_NAMES.postdeploymentSteps);
+    checkAdditionalField(parsed.additionalFields.deploymentInformation, fieldConfig.deploymentInformation, ADDITIONAL_FIELD_DISPLAY_NAMES.deploymentInformation);
+    return { operations, skippedFields, convertedFields };
+}
+/**
+ * Update the lastSyncedRevision in a markdown file content
+ */
+export function updateSyncRevision(content, newRevision) {
+    // Update lastSyncedRevision in frontmatter
+    const updatedContent = content.replace(/lastSyncedRevision:\s*\d+/, `lastSyncedRevision: ${newRevision}`);
+    // Update lastSyncedAt timestamp
+    return updatedContent.replace(/lastSyncedAt:\s*[^\n]+/, `lastSyncedAt: ${new Date().toISOString()}`);
+}
+/**
+ * Check if a work item frontmatter indicates a new (not yet created) work item
+ * New work items don't have an 'id' field
+ */
+export function isNewWorkItem(frontmatter) {
+    return !frontmatter.id || typeof frontmatter.id !== 'number';
+}
+/**
+ * Parse a markdown file for a NEW work item (no id required)
+ */
+export function parseNewWorkItemMarkdown(content) {
+    // Extract frontmatter between ---
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        throw new Error('Invalid work item markdown file: missing YAML frontmatter');
+    }
+    const frontmatterRaw = frontmatterMatch[1];
+    const frontmatterData = parseFrontmatter(frontmatterRaw);
+    // Validate required fields for new work items
+    if (!frontmatterData.parent || typeof frontmatterData.parent !== 'number') {
+        throw new Error('New work item files require a "parent" field with the parent work item ID');
+    }
+    if (!frontmatterData.title || typeof frontmatterData.title !== 'string') {
+        throw new Error('New work item files require a "title" field');
+    }
+    const frontmatter = {
+        title: frontmatterData.title,
+        type: frontmatterData.type || 'User Story',
+        state: frontmatterData.state || 'New',
+        parent: frontmatterData.parent,
+        assignedTo: frontmatterData.assignedTo,
+        storyPoints: frontmatterData.storyPoints,
+        moscow: frontmatterData.moscow,
+        tags: frontmatterData.tags,
+        areaPath: frontmatterData.areaPath,
+        iterationPath: frontmatterData.iterationPath,
+    };
+    // Extract content after frontmatter
+    const contentAfterFrontmatter = content.slice(frontmatterMatch[0].length);
+    // Helper to extract a section by heading (reuse from parseWorkItemMarkdown)
+    const extractSection = (sectionName) => {
+        const regex = new RegExp(`#\\s+${escapeRegex(sectionName)}\\s*\\n([\\s\\S]*?)(?=\\n---\\n|\\n#\\s+|$)`, 'i');
+        const match = contentAfterFrontmatter.match(regex);
+        if (!match)
+            return undefined;
+        const sectionContent = match[1].trim();
+        if (sectionContent === `_No ${sectionName.toLowerCase()} provided._`) {
+            return undefined;
+        }
+        return sectionContent || undefined;
+    };
+    // Extract primary sections
+    let description = extractSection('Description') || '';
+    if (description === '_No description provided._' || description === '[Your description here]') {
+        description = '';
+    }
+    let acceptanceCriteria = extractSection('Acceptance Criteria') || '';
+    if (acceptanceCriteria === '_No acceptance criteria provided._' || acceptanceCriteria === '[Your acceptance criteria here]') {
+        acceptanceCriteria = '';
+    }
+    // Extract additional fields (optional)
+    const additionalFields = {};
+    const howToTest = extractSection('How to Test');
+    if (howToTest)
+        additionalFields.howToTest = howToTest;
+    const predeploymentSteps = extractSection('Predeployment Steps');
+    if (predeploymentSteps)
+        additionalFields.predeploymentSteps = predeploymentSteps;
+    const postdeploymentSteps = extractSection('Postdeployment Steps');
+    if (postdeploymentSteps)
+        additionalFields.postdeploymentSteps = postdeploymentSteps;
+    const deploymentInformation = extractSection('Deployment Information');
+    if (deploymentInformation)
+        additionalFields.deploymentInformation = deploymentInformation;
+    return {
+        frontmatter,
+        description,
+        acceptanceCriteria,
+        additionalFields,
+        rawContent: content,
+    };
+}
+/**
+ * Build ADO fields object for creating a new work item
+ * Inherits areaPath and iterationPath from parent work item
+ */
+export function buildNewWorkItemFields(parsed, parentWorkItem) {
+    const parentFields = parentWorkItem.fields || {};
+    const fieldConfig = getAdditionalFieldConfig();
+    const fields = {
+        'System.Title': parsed.frontmatter.title,
+        'System.State': parsed.frontmatter.state || 'New',
+    };
+    // Set description if provided
+    if (parsed.description) {
+        fields['System.Description'] = parsed.description;
+    }
+    // Set acceptance criteria if provided
+    if (parsed.acceptanceCriteria) {
+        fields['Microsoft.VSTS.Common.AcceptanceCriteria'] = parsed.acceptanceCriteria;
+    }
+    // Story points - only set if it's a valid number (including 0)
+    // YAML may parse empty value as null/undefined, or string if quoted
+    // Using 'any' cast because YAML parser may return types not matching interface
+    const storyPointsValue = parsed.frontmatter.storyPoints;
+    if (storyPointsValue !== undefined && storyPointsValue !== null && storyPointsValue !== '') {
+        const storyPoints = Number(storyPointsValue);
+        if (!isNaN(storyPoints)) {
+            fields['Microsoft.VSTS.Scheduling.StoryPoints'] = storyPoints;
+        }
+    }
+    // MoSCoW (custom field) - only set if non-empty
+    const moscowValue = parsed.frontmatter.moscow;
+    if (moscowValue && String(moscowValue).trim() !== '') {
+        fields['Custom.MoSCoW'] = moscowValue;
+    }
+    // Tags - ensure it's an array with items before joining
+    if (Array.isArray(parsed.frontmatter.tags) && parsed.frontmatter.tags.length > 0) {
+        fields['System.Tags'] = parsed.frontmatter.tags.join('; ');
+    }
+    // Inherit areaPath from parent if not specified
+    if (parsed.frontmatter.areaPath) {
+        fields['System.AreaPath'] = parsed.frontmatter.areaPath;
+    }
+    else if (parentFields['System.AreaPath']) {
+        fields['System.AreaPath'] = parentFields['System.AreaPath'];
+    }
+    // Inherit iterationPath from parent if not specified
+    if (parsed.frontmatter.iterationPath) {
+        fields['System.IterationPath'] = parsed.frontmatter.iterationPath;
+    }
+    else if (parentFields['System.IterationPath']) {
+        fields['System.IterationPath'] = parentFields['System.IterationPath'];
+    }
+    // Additional fields
+    if (parsed.additionalFields.howToTest) {
+        fields[fieldConfig.howToTest] = parsed.additionalFields.howToTest;
+    }
+    if (parsed.additionalFields.predeploymentSteps) {
+        fields[fieldConfig.predeploymentSteps] = parsed.additionalFields.predeploymentSteps;
+    }
+    if (parsed.additionalFields.postdeploymentSteps) {
+        fields[fieldConfig.postdeploymentSteps] = parsed.additionalFields.postdeploymentSteps;
+    }
+    if (parsed.additionalFields.deploymentInformation) {
+        fields[fieldConfig.deploymentInformation] = parsed.additionalFields.deploymentInformation;
+    }
+    return fields;
+}
+/**
+ * Generate a new work item template markdown file
+ */
+export function generateNewWorkItemTemplate(parentId, parentTitle, project, workItemType = 'User Story') {
+    // Only include required fields - optional fields omitted to avoid empty value issues
+    const frontmatter = {
+        title: 'New User Story Title',
+        type: workItemType,
+        state: 'New',
+        parent: parentId,
+    };
+    let content = serializeFrontmatter(frontmatter);
+    content += '\n';
+    content += `<!-- Optional frontmatter fields (add to YAML above if needed):\n`;
+    content += `storyPoints: 3\n`;
+    content += `moscow: Should Have\n`;
+    content += `tags:\n`;
+    content += `- tag1\n`;
+    content += `- tag2\n`;
+    content += `-->\n\n`;
+    content += `> Parent: **#${parentId}** - ${parentTitle}\n`;
+    content += `> Project: ${project}\n`;
+    content += '\n# Description\n\n';
+    content += '[Your description here]\n\n';
+    content += '---\n\n';
+    content += '# Acceptance Criteria\n\n';
+    content += '[Your acceptance criteria here]\n';
+    return content;
+}
+/**
+ * Update a new work item file after creation with the assigned ID
+ * Converts it from a "new" file to a synced file with proper frontmatter
+ */
+export function convertNewFileToSynced(content, workItemId, revision, url) {
+    // Parse the existing content
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        throw new Error('Invalid work item markdown file: missing YAML frontmatter');
+    }
+    const frontmatterRaw = frontmatterMatch[1];
+    const frontmatterData = parseFrontmatter(frontmatterRaw);
+    const contentAfterFrontmatter = content.slice(frontmatterMatch[0].length);
+    // Build new frontmatter with id and sync metadata
+    const newFrontmatter = {
+        id: workItemId,
+        title: frontmatterData.title || '',
+        type: frontmatterData.type || 'User Story',
+        state: frontmatterData.state || 'New',
+        url: url,
+    };
+    // Copy optional fields
+    if (frontmatterData.assignedTo)
+        newFrontmatter.assignedTo = frontmatterData.assignedTo;
+    if (frontmatterData.storyPoints)
+        newFrontmatter.storyPoints = frontmatterData.storyPoints;
+    if (frontmatterData.parent)
+        newFrontmatter.parent = frontmatterData.parent;
+    if (frontmatterData.moscow)
+        newFrontmatter.moscow = frontmatterData.moscow;
+    if (frontmatterData.tags && frontmatterData.tags.length > 0)
+        newFrontmatter.tags = frontmatterData.tags;
+    if (frontmatterData.areaPath)
+        newFrontmatter.areaPath = frontmatterData.areaPath;
+    if (frontmatterData.iterationPath)
+        newFrontmatter.iterationPath = frontmatterData.iterationPath;
+    // Add sync metadata
+    newFrontmatter.lastSyncedRevision = revision;
+    newFrontmatter.lastSyncedAt = new Date().toISOString();
+    // Remove the "Parent:" and "Project:" note lines from the content
+    let cleanedContent = contentAfterFrontmatter
+        .replace(/>\s*Parent:.*\n/i, '')
+        .replace(/>\s*Project:.*\n/i, '');
+    return serializeFrontmatter(newFrontmatter) + cleanedContent;
+}
+//# sourceMappingURL=markdown-serializer.js.map