@docupace/pipeline 1.0.85 → 1.0.87

package/src/changeset/convert.js

@@ -0,0 +1,461 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import semver from 'semver';
+import { getReleaseNotes, JIRA_BASE_URL } from './openai.js';
+import { getJiraReleaseNotes, updateJiraReleaseNotes } from '../next/jira.js';
+import { uploadToCanny } from './canny.js';
+import { labelIDMap } from './config.js';
+
+/**
+ * Update multiple details links in text
+ * Similar to updateDetailsLinkInText but supports multiple [[details]](...) links
+ * @param {string} text - Text containing [[details]](link) patterns
+ * @param {Function} processDetailsLink - Function to process each link
+ * @param {Object} params - Parameters to pass to processDetailsLink
+ * @returns {Promise<string>} - Updated text with processed links
+ */
+async function updateMultipleDetailsLinks(text, processDetailsLink, params) {
+  const detailsLinkRegex = /\[\[details\]\]\((.*?)\)/g;
+
+  let result = text;
+  const matches = [...text.matchAll(detailsLinkRegex)];
+
+  for (const match of matches) {
+    const originalLink = match[1];
+    const newLink = await processDetailsLink(originalLink, params);
+
+    if (newLink) {
+      // Replace this specific occurrence
+      result = result.replace(
+        `[[details]](${originalLink})`,
+        `[[details]](${newLink})`,
+      );
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Extract Jira ticket IDs from a CHANGELOG.md file starting from a specific version
+ * Scans the entire file to handle unordered versions
+ * @param {string} changelogPath - Path to the CHANGELOG.md file
+ * @param {string} startVersion - Version to start from (e.g., "1.14.0")
+ * @returns {Array<string>} - Array of Jira ticket IDs
+ */
+function extractJiraTicketsFromChangelog(changelogPath, startVersion) {
+  const content = fs.readFileSync(changelogPath, 'utf8');
+  const lines = content.split('\n');
+
+  const tickets = [];
+  let shouldCapture = false;
+
+  // Parse major.minor from startVersion (ignore patch)
+  const [startMajor, startMinor] = startVersion.split('.').map(Number);
+
+  // Scan entire file to handle unordered versions
+  for (const line of lines) {
+    // Check for version headers like ## 1.14.52
+    const versionMatch = line.match(/^##\s+(\d+)\.(\d+)\.(\d+)/);
+    if (versionMatch) {
+      const [, major, minor] = versionMatch.map(Number);
+
+      // Check if this version meets the criteria
+      if (major > startMajor || (major === startMajor && minor >= startMinor)) {
+        shouldCapture = true;
+      } else {
+        shouldCapture = false;
+      }
+    }
+
+    // Extract Jira ticket IDs from lines like: - ea7bce9: Some text [DC-91190]
+    // Skip lines that contain [[details]] as they have already been processed
+    if (shouldCapture && !line.includes('[[details]]')) {
+      const ticketMatch = line.match(/\[([A-Z]+-\d+)\]/g);
+      if (ticketMatch) {
+        ticketMatch.forEach((match) => {
+          const ticketId = match.replace(/[[\]]/g, '');
+          if (!tickets.includes(ticketId)) {
+            tickets.push(ticketId);
+          }
+        });
+      }
+    }
+  }
+
+  return tickets;
+}
+
+/**
+ * Get labels for Canny based on version
+ * @param {string} version - Version string (e.g., "1.14.52")
+ * @param {Object} releaseNote - Release note object from YAML
+ * @returns {Array<string>} - Array of label names
+ */
+function getLabelsForConversion(version) {
+  const parsed = semver.parse(version);
+  if (!parsed) {
+    return [];
+  }
+  const majorMinor = `${parsed.major}.${parsed.minor}`;
+  const componentName = 'Enterprise';
+  const labels = [`${componentName} - ${majorMinor}`];
+  return labels;
+}
+
+/**
+ * Get label IDs for Canny
+ * @param {Array<string>} labels - Array of label names
+ * @returns {Promise<Array<string>>} - Array of label IDs
+ */
+async function getLabelIDsForConversion(labels) {
+  let cannyConfig;
+  try {
+    const cannyConfigPath = path.join(
+      process.cwd(),
+      '.changeset',
+      'canny.json',
+    );
+    cannyConfig = JSON.parse(fs.readFileSync(cannyConfigPath, 'utf-8'));
+  } catch (e) {
+    console.error('Canny read canny.json file', e);
+  }
+
+  const mergedLabelMap = { ...labelIDMap, ...cannyConfig?.labels };
+  return labels.map((label) => mergedLabelMap[label]).filter(Boolean);
+}
+
+function stripAfterTicketLink(logMessage) {
+  return logMessage.replace(/\s*\[\[[A-Z]+-\d+\]\]\([^)]+\).*/s, '');
+}
+
+/**
+ * Extract summary description from changelog entry text
+ * @param {string} text - Changelog entry text
+ * @returns {string} - Extracted summary
+ */
+function extractSummaryFromChangelog(text) {
+  const lines = text.split(/\r?\n/);
+  const summaryLines = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith('[[')) {
+      break;
+    }
+    summaryLines.push(lines[i]);
+  }
+
+  return stripAfterTicketLink(summaryLines.join('\n').trim());
+}
+
+/**
+ * Fetch new link for conversion workflow
+ * This is specifically designed for convert-complete and doesn't modify fetchNewLink
+ * @param {string} oldLink - Original link (yaml file path)
+ * @param {Object} params - Parameters containing version and taskTicketId
+ * @param {string} params.version - Version string from changelog (e.g., "1.14.52")
+ * @param {string} params.taskTicketId - Task ticket ID from changelog entry
+ * @param {string} params.changelogEntry - Full changelog entry text for summary extraction
+ * @param {string} params.changelogPath - Path to the CHANGELOG.md file
+ * @returns {Promise<string>} - New Canny URL or existing URL
+ */
+async function fetchNewLinkForConversion(oldLink, params) {
+  if (!oldLink.includes('.yaml')) {
+    return oldLink; // Not a yaml link, return as-is
+  }
+
+  const { version, taskTicketId, changelogEntry, changelogPath } = params;
+
+  // Normalize and resolve the yaml file path
+  // The oldLink is a relative path from the changelog (e.g., .release-notes/DC-91190.yaml)
+  // We need to resolve it relative to the CHANGELOG.md directory
+  const normalizedOldLink = oldLink.replaceAll('\\', '/');
+  const changelogDir = path.dirname(changelogPath);
+  const yamlPath = path.resolve(changelogDir, normalizedOldLink);
+
+  if (!fs.existsSync(yamlPath)) {
+    console.error(`❌ YAML file not found: ${yamlPath}`);
+    return oldLink;
+  }
+
+  // Read the yaml file to get release note data
+  const releaseNote = yaml.load(fs.readFileSync(yamlPath, 'utf-8'));
+  const mainTicketId = releaseNote.ticketId;
+
+  // Extract summary from the changelog entry
+  const summary = changelogEntry
+    ? extractSummaryFromChangelog(changelogEntry)
+    : '';
+
+  console.log(`📝 Processing ${taskTicketId} (main: ${mainTicketId})...`);
+
+  // Calculate labels based on the version
+  const labels = getLabelsForConversion(version, releaseNote);
+  const labelIDs = await getLabelIDsForConversion(labels);
+
+  // Helper function to upload to Canny
+  const uploadToCannyInternal = async () => {
+    console.log(`📤 Uploading ${mainTicketId} to Canny...`);
+    const data = await uploadToCanny(releaseNote, labelIDs);
+    return data;
+    //return { url: 'test url for ' + releaseNote.ticketId };
+  };
+
+  // Helper function to update Jira
+  const uploadToJiraInternal = async (ticketId, url) => {
+    console.log(
+      `📝 Updating Jira ${ticketId} with Canny URL ${url} and Summary : ${summary}`,
+    );
+    await updateJiraReleaseNotes(ticketId, summary, url, labels);
+  };
+
+  // Check if the main ticket has release notes in Jira
+  const jiraReleaseInfo = await getJiraReleaseNotes(mainTicketId);
+
+  // If task ticket differs from main ticket, handle both
+  if (mainTicketId !== taskTicketId) {
+    const subtaskJiraReleaseInfo = await getJiraReleaseNotes(taskTicketId);
+
+    // If subtask already has a URL, return it
+    if (subtaskJiraReleaseInfo?.url) {
+      console.log(`✅ ${taskTicketId} already has Canny URL`);
+      return subtaskJiraReleaseInfo.url;
+    }
+
+    // If main ticket has a URL, use it for subtask
+    if (jiraReleaseInfo?.url) {
+      await uploadToJiraInternal(taskTicketId, jiraReleaseInfo.url);
+      return jiraReleaseInfo.url;
+    }
+
+    // Otherwise, upload to Canny and update both tickets
+    const data = await uploadToCannyInternal();
+    await uploadToJiraInternal(taskTicketId, data.url);
+    await uploadToJiraInternal(mainTicketId, data.url);
+    return data.url;
+  } else {
+    // Task ticket is the same as main ticket
+    if (jiraReleaseInfo?.url) {
+      console.log(`✅ ${mainTicketId} already has Canny URL`);
+      return jiraReleaseInfo.url;
+    }
+
+    // Upload to Canny and update Jira
+    const data = await uploadToCannyInternal();
+    await uploadToJiraInternal(mainTicketId, data.url);
+    return data.url;
+  }
+}
+
+/**
+ * Replace Jira ticket references in CHANGELOG.md with enhanced links
+ * @param {string} changelogPath - Path to the CHANGELOG.md file
+ * @param {string} ticketId - Jira ticket ID (e.g., "DC-91190")
+ * @param {string} yamlFilePath - Path to the generated YAML file
+ */
+function replaceTicketInChangelog(changelogPath, ticketId, yamlFilePath) {
+  let content = fs.readFileSync(changelogPath, 'utf8');
+
+  // Calculate relative path from the CHANGELOG.md location to the yaml file
+  const changelogDir = path.dirname(changelogPath);
+  const relYamlFilePath = path
+    .relative(changelogDir, yamlFilePath)
+    .replaceAll('\\', '/');
+
+  // Replace [DC-XXXX] with [[DC-XXXX]](url) [[details]](yaml-path)
+  // Use a regex that matches [TICKET-ID] but not when it's already been replaced
+  const regex = new RegExp(`\\[${ticketId}\\](?!\\()`, 'g');
+  const replacement = `[[${ticketId}]](${JIRA_BASE_URL}/browse/${ticketId}) [[details]](${relYamlFilePath})`;
+
+  content = content.replace(regex, replacement);
+
+  fs.writeFileSync(changelogPath, content, 'utf8');
+}
+
+/**
+ * Convert changelog entries to Canny format - Part 1 (Prepare)
+ * This function processes the changelog to generate YAML files and update ticket references
+ * @param {string} versionId - Version ID (e.g., "1.14") to start processing from
+ * @param {string} changelogPath - Optional path to CHANGELOG.md (defaults to ./CHANGELOG.md)
+ */
+
+export async function convertPrepare(
+  versionId,
+  changelogPath = './CHANGELOG.md',
+) {
+  console.log(`🔄 Starting convert-prepare for version ${versionId}...`);
+
+  const resolvedChangelogPath = path.resolve(process.cwd(), changelogPath);
+
+  if (!fs.existsSync(resolvedChangelogPath)) {
+    throw new Error(`CHANGELOG.md not found at ${resolvedChangelogPath}`);
+  }
+
+  // Extract Jira tickets from the changelog
+  console.log('📋 Extracting Jira tickets from changelog...');
+  const tickets = extractJiraTicketsFromChangelog(
+    resolvedChangelogPath,
+    versionId,
+  );
+  console.log(`Found ${tickets.length} tickets to process`);
+
+  // Process tickets in parallel batches of 5
+  const BATCH_SIZE = 5;
+  let processedCount = 0;
+  let errorCount = 0;
+
+  for (let i = 0; i < tickets.length; i += BATCH_SIZE) {
+    const batch = tickets.slice(i, i + BATCH_SIZE);
+    console.log(
+      `\n🔄 Processing batch ${Math.floor(i / BATCH_SIZE) + 1} (${batch.length} tickets)...`,
+    );
+
+    // Process all tickets in the batch in parallel
+    const batchPromises = batch.map(async (ticketId) => {
+      try {
+        console.log(`📝 Processing ${ticketId}...`);
+
+        // Generate release notes and YAML file
+        const { yamlFilePath } = await getReleaseNotes(ticketId);
+
+        return {
+          success: true,
+          ticketId,
+          yamlFilePath,
+        };
+      } catch (error) {
+        console.error(`❌ Error processing ${ticketId}:`, error.message);
+        return {
+          success: false,
+          ticketId,
+          error: error.message,
+        };
+      }
+    });
+
+    // Wait for all tickets in the batch to complete
+    const results = await Promise.all(batchPromises);
+
+    // Update the changelog with all successful results from this batch
+    for (const result of results) {
+      if (result.success) {
+        replaceTicketInChangelog(
+          resolvedChangelogPath,
+          result.ticketId,
+          result.yamlFilePath,
+        );
+        console.log(`✅ Successfully processed ${result.ticketId}`);
+        processedCount++;
+      } else {
+        errorCount++;
+      }
+    }
+
+    console.log(
+      `✨ Batch ${Math.floor(i / BATCH_SIZE) + 1} completed. Updated changelog.`,
+    );
+  }
+
+  console.log(`\n✨ Convert-prepare completed!`);
+  console.log(`   Processed: ${processedCount}`);
+  console.log(`   Errors: ${errorCount}`);
+  console.log(`\n📄 Updated changelog at: ${resolvedChangelogPath}`);
+}
+
+/**
+ * Parse changelog to extract context for each details link
+ * @param {string} content - Changelog content
+ * @param {string} changelogPath - Path to the CHANGELOG.md file
+ * @returns {Map<string, Object>} - Map of yaml file paths to their context
+ */
+function parseChangelogContext(content, changelogPath) {
+  const lines = content.split('\n');
+  const contextMap = new Map();
+  let currentVersion = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Check for version headers like ## 1.14.52
+    const versionMatch = line.match(/^##\s+(\d+\.\d+\.\d+)/);
+    if (versionMatch) {
+      currentVersion = versionMatch[1];
+      continue;
+    }
+
+    // Extract entries with details links
+    // Format: - commit: text [TICKET-ID] [[TICKET-ID]](url) [[details]](yaml-path)
+    const detailsMatch = line.match(/\[\[details\]\]\((.*?\.yaml)\)/);
+    if (detailsMatch && currentVersion) {
+      const yamlPath = detailsMatch[1];
+
+      // Extract ticket ID from the line
+      const ticketMatch = line.match(/\[\[([A-Z]+-\d+)\]\]/);
+      const taskTicketId = ticketMatch ? ticketMatch[1] : null;
+
+      // Extract the full entry text (everything after "- commit:")
+      const entryMatch = line.match(/^-\s+[a-f0-9]+:\s+(.*)/);
+      const changelogEntry = entryMatch ? entryMatch[1] : line;
+
+      if (taskTicketId) {
+        contextMap.set(yamlPath, {
+          version: currentVersion,
+          taskTicketId,
+          changelogEntry,
+          changelogPath,
+        });
+      }
+    }
+  }
+
+  return contextMap;
+}
+
+/**
+ * Convert changelog entries to Canny format - Part 2 (Complete)
+ * This function updates the details links to point to Canny URLs
+ * @param {string} changelogPath - Optional path to CHANGELOG.md (defaults to ./CHANGELOG.md)
+ */
+export async function convertComplete(changelogPath = './CHANGELOG.md') {
+  console.log('🔄 Starting convert-complete...');
+
+  const resolvedChangelogPath = path.resolve(process.cwd(), changelogPath);
+
+  if (!fs.existsSync(resolvedChangelogPath)) {
+    throw new Error(`CHANGELOG.md not found at ${resolvedChangelogPath}`);
+  }
+
+  // Read the changelog content
+  let content = fs.readFileSync(resolvedChangelogPath, 'utf8');
+
+  console.log('🔗 Parsing changelog context...');
+  const contextMap = parseChangelogContext(content, resolvedChangelogPath);
+
+  console.log(`📝 Found ${contextMap.size} entries to process`);
+  console.log('🔗 Updating details links to Canny URLs...');
+
+  // Create a wrapper function that looks up context for each link
+  const processLinkWithContext = async (oldLink) => {
+    const context = contextMap.get(oldLink);
+    if (!context) {
+      console.warn(`⚠️  No context found for ${oldLink}, skipping...`);
+      return oldLink;
+    }
+
+    return await fetchNewLinkForConversion(oldLink, context);
+  };
+
+  // Update all [[details]] links in the changelog to point to Canny URLs
+  const updatedContent = await updateMultipleDetailsLinks(
+    content,
+    processLinkWithContext,
+    null,
+  );
+
+  // Write the updated content back to the changelog
+  fs.writeFileSync(resolvedChangelogPath, updatedContent, 'utf8');
+
+  console.log(`\n✨ Convert-complete completed!`);
+  console.log(`📄 Updated changelog at: ${resolvedChangelogPath}`);
+}

package/src/changeset/create-canny.js

@@ -0,0 +1,86 @@
+import {
+  createChangesetDirectory,
+  extractJiraTicketId,
+  getCurrentBranch,
+} from './create.js';
+import path from 'path';
+import fs from 'fs';
+import { getReleaseNotes, JIRA_BASE_URL } from './openai.js';
+
+export async function createChangesetForPackageCanny(
+  packages,
+  selectedJiraIssueKey,
+) {
+  try {
+    let jiraTicketId;
+
+    if (selectedJiraIssueKey) {
+      jiraTicketId = selectedJiraIssueKey;
+    } else {
+      const branchName = await getCurrentBranch();
+
+      jiraTicketId = extractJiraTicketId(branchName);
+    }
+
+    console.log(`Generating release notes for ${jiraTicketId}`);
+
+    const { enhancedNotes, yamlFilePath, mainTicketId, summary } =
+      await getReleaseNotes(jiraTicketId);
+
+    const { changeType } = enhancedNotes;
+    const change_type = changeType == 'Fixed' ? 'patch' : 'minor';
+
+    // Step 4: Generate release notes using OpenAI
+    console.log(`Change type: ${change_type}`);
+    console.log(`Release note: ${summary}`);
+
+    // Step 5: Create a changeset .md file for all packages
+    await writeChangesetFile(
+      packages,
+      jiraTicketId,
+      mainTicketId,
+      change_type,
+      summary,
+      yamlFilePath,
+    );
+
+    console.log('Changeset created successfully!');
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Writes the changeset file
+ */
+async function writeChangesetFile(
+  packages,
+  taskTicketId,
+  mainTicketId,
+  changeType,
+  summary,
+  yamlFilePath,
+) {
+  // Generate the YAML frontmatter for multiple packages
+  const packageEntries = packages
+    .map((pkg) => `'${pkg.name}': ${changeType}`)
+    .join('\n');
+
+  const relYamlFilePath = path
+    .relative(path.resolve(process.cwd(), '.changeset'), yamlFilePath)
+    .replaceAll('\\', '/');
+
+  const changesetContent = `---
+${packageEntries}
+---
+
+${summary}
+[[${taskTicketId}]](${JIRA_BASE_URL}/browse/${taskTicketId}) [[details]](${relYamlFilePath})`;
+
+  const changesetFile = `./.changeset/${taskTicketId}.md`;
+
+  await createChangesetDirectory();
+  await fs.promises.writeFile(changesetFile, changesetContent);
+  console.log(`Created changeset file at ${changesetFile}`);
+}

package/src/changeset/create-simple.js

@@ -0,0 +1,131 @@
+import {
+  createChangesetDirectory,
+  extractJiraTicketId,
+  getCurrentBranch,
+} from './create.js';
+import OpenAI from 'openai';
+import z from 'zod';
+import { zodResponseFormat } from 'openai/helpers/zod';
+import fs from 'fs';
+
+export async function createChangesetForPackageSimple(packages) {
+  try {
+    // Step 1: Get the current branch name
+    const branchName = await getCurrentBranch();
+
+    // Step 2: Extract Jira ticket number
+    const jiraTicketId = extractJiraTicketId(branchName);
+
+    // Step 3: Fetch Jira ticket data
+    const jiraTicketData = await fetchJiraTicketData(jiraTicketId);
+    const jiraSummary = jiraTicketData.fields.summary;
+    console.log(
+      `Generating release notes for ${jiraTicketId} - ${jiraSummary}`,
+    );
+
+    // Step 4: Generate release notes using OpenAI
+    const { change_type, summary } = await generateReleaseNotes(jiraTicketData);
+    console.log(`Change type: ${change_type}`);
+    console.log(`Release note: ${summary}`);
+
+    // Step 5: Create a changeset .md file for all packages
+    await writeJiraChangesetFile(packages, jiraTicketId, change_type, summary);
+
+    console.log('Changeset created successfully!');
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Fetches Jira ticket data from Jira API
+ */
+async function fetchJiraTicketData(jiraTicketId) {
+  const jiraBaseUrl = 'https://docupacellc.atlassian.net';
+  const jiraEmail = process.env.JIRA_API_EMAIL;
+  const jiraApiKey = process.env.JIRA_API_KEY;
+  const jiraFullApiKey = `${jiraEmail}:${jiraApiKey}`;
+  const jiraUrl = `${jiraBaseUrl}/rest/api/2/issue/${jiraTicketId}`;
+
+  const jiraResponse = await fetch(jiraUrl, {
+    headers: {
+      Authorization: `Basic ${Buffer.from(jiraFullApiKey).toString('base64')}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!jiraResponse.ok) {
+    throw new Error(
+      `Failed to fetch Jira ticket ${jiraTicketId}. Status: ${jiraResponse.status}, Ticket URL: ${jiraUrl}`,
+    );
+  }
+
+  return await jiraResponse.json();
+}
+
+/**
+ * Generates release notes using OpenAI
+ */
+async function generateReleaseNotes(jiraTicketData) {
+  const openaiClient = new OpenAI({
+    apiKey: process.env['OPENAI_API_KEY'],
+  });
+
+  const ChangeRequestSchema = z.object({
+    change_type: z.enum(['patch', 'minor']),
+    summary: z.string(),
+    jira_ticket_id: z.string(),
+  });
+
+  const openAiResponse = await openaiClient.chat.completions.create({
+    model: 'gpt-4o-mini',
+    messages: [
+      {
+        role: 'system',
+        content: `Process JSON from a Jira ticket to generate simple maximum 2 sentence release note for the ticket and determine the change type for bug it should be a patch for new feature it should be a minor change`,
+      },
+      {
+        role: 'user',
+        content: JSON.stringify(jiraTicketData),
+      },
+    ],
+    response_format: zodResponseFormat(ChangeRequestSchema, 'changeset_schema'),
+    temperature: 0,
+  });
+
+  const assistantResponse = openAiResponse.choices[0].message.content;
+  return JSON.parse(assistantResponse);
+}
+
+/**
+ * Writes the changeset file
+ */
+async function writeJiraChangesetFile(
+  packages,
+  jiraTicketId,
+  changeType,
+  summary,
+) {
+  const text = `${summary} [${jiraTicketId}]`;
+  await writeChangesetFile(packages, jiraTicketId, changeType, text);
+}
+
+export async function writeChangesetFile(packages, filename, changeType, text) {
+  const packageEntries = packages
+    .map((pkg) => `'${pkg.name}': ${changeType}`)
+    .join('\n');
+
+  const changesetContent = `---
+${packageEntries}
+---
+
+${text}
+`;
+
+  const changesetFile = `./.changeset/${filename}.md`;
+
+  await createChangesetDirectory();
+  await fs.promises.writeFile(changesetFile, changesetContent);
+  console.log(`Created changeset file at ${changesetFile}`);
+}