@docupace/pipeline 1.0.85 → 1.0.87

package/src/changeset/openai.js

@@ -0,0 +1,567 @@
+#!/usr/bin/env node
+import dotenv from 'dotenv';
+dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
+
+import fs from 'fs';
+import path from 'path';
+import fetch from 'node-fetch';
+import yaml from 'js-yaml';
+import { z } from 'zod';
+
+// Configuration
+export const JIRA_BASE_URL =
+  process.env.JIRA_BASE_URL || 'https://docupacellc.atlassian.net';
+
+const JIRA_API_KEY = process.env.JIRA_API_KEY;
+const JIRA_API_EMAIL = process.env.JIRA_API_EMAIL;
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+const OPENAI_MODEL = process.env.OPENAI_MODEL || 'gpt-4.1';
+
+const CHANGESET_DIR = path.join(process.cwd(), '.release-notes');
+
+// Define the Zod schema for OpenAI response
+const openAiResponseSchema = z.object({
+  title: z
+    .string()
+    .describe('A concise title for the release note (3-8 words)'),
+  summary: z.string().describe('A brief user-facing summary of changes'),
+  technicalDescription: z
+    .string()
+    .optional()
+    .describe('Developer-friendly description of technical changes'),
+  userFacingDescription: z
+    .string()
+    .optional()
+    .describe('Plain-language description of changes from a user perspective'),
+  technicalOnly: z
+    .boolean()
+    .describe(
+      'Whether this change is technical-only with no user-visible impact',
+    ),
+  changeSize: z
+    .enum(['Small', 'Medium', 'Large'])
+    .describe('Size/scope of the change'),
+  changeType: z.enum(['New', 'Improved', 'Fixed']).describe('Type of change'),
+});
+
+// Define the Zod schema for changelog summary
+const changeLogSummarySchema = z.object({
+  summary: z
+    .string()
+    .describe(
+      'A concise summary of what is being implemented in this ticket or subtask',
+    ),
+});
+
+/**
+ * Log token usage information
+ * @param {string} ticketId - The JIRA ticket ID
+ * @param {Object} tokenUsage - Token usage data
+ */
+/**
+ * Strip sensitive or unnecessary fields from a JIRA ticket object
+ * @param {Object} ticketData - The JIRA ticket data to clean
+ * @returns {Object} - The cleaned JIRA ticket data
+ */
+function stripJiraTicketFields(ticketData) {
+  if (!ticketData || !ticketData.fields) return ticketData;
+
+  const fieldsToStrip = [
+    'customfield_10020',
+    'worklog',
+    'creator',
+    'reporter',
+    'assignee',
+    'customfield_10095',
+    'customfield_10000',
+    'votes',
+    'watches',
+    'customfield_10083',
+  ];
+
+  const cleanedData = JSON.parse(JSON.stringify(ticketData)); // Create a deep copy
+
+  // Strip specified fields
+  fieldsToStrip.forEach((field) => {
+    if (cleanedData.fields[field]) {
+      delete cleanedData.fields[field];
+    }
+  });
+
+  // Remove all null fields
+  Object.keys(cleanedData.fields).forEach((field) => {
+    if (cleanedData.fields[field] === null) {
+      delete cleanedData.fields[field];
+    }
+  });
+
+  // Clean up comments if they exist
+  if (cleanedData.fields.comment && cleanedData.fields.comment.comments) {
+    cleanedData.fields.comment.comments =
+      cleanedData.fields.comment.comments.map((comment) => {
+        const cleanComment = { ...comment };
+        if (cleanComment.author) delete cleanComment.author;
+        if (cleanComment.updateAuthor) delete cleanComment.updateAuthor;
+
+        // Remove null fields from comments
+        Object.keys(cleanComment).forEach((key) => {
+          if (cleanComment[key] === null) {
+            delete cleanComment[key];
+          }
+        });
+
+        return cleanComment;
+      });
+  }
+
+  return cleanedData;
+}
+
+/**
+ * Fetch JIRA ticket information
+ * @param {string} ticketId - The JIRA ticket ID
+ * @returns {Promise<Object>} - The JIRA ticket data
+ */
+async function fetchJiraTicket(ticketId) {
+  if (!JIRA_API_KEY || !JIRA_API_EMAIL) {
+    console.warn('JIRA credentials not provided. Skipping JIRA API call.');
+    return null;
+  }
+
+  const auth = Buffer.from(`${JIRA_API_EMAIL}:${JIRA_API_KEY}`).toString(
+    'base64',
+  );
+
+  try {
+    const response = await fetch(
+      `${JIRA_BASE_URL}/rest/api/3/issue/${ticketId}`,
+      {
+        headers: {
+          Authorization: `Basic ${auth}`,
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    if (!response.ok) {
+      console.error(
+        `Error fetching JIRA ticket ${ticketId}: ${response.statusText}`,
+      );
+      return null;
+    }
+
+    const data = await response.json();
+    const cleanedData = stripJiraTicketFields(data);
+
+    // Check if the ticket is a subtask
+    const isSubtask = cleanedData.fields.issuetype?.subtask || false;
+    let mainTicketId, subTaskTicketId, mainTicketData, subTaskTicketData;
+
+    // If it's a subtask, fetch the parent ticket as well
+    if (isSubtask && cleanedData.fields.parent) {
+      const parentTicketId = cleanedData.fields.parent.key;
+      mainTicketId = parentTicketId;
+      subTaskTicketId = ticketId;
+      delete cleanedData.fields.parent;
+
+      console.log(
+        `Fetching parent ticket ${parentTicketId} for subtask ${ticketId}`,
+      );
+
+      const parentResponse = await fetch(
+        `${JIRA_BASE_URL}/rest/api/3/issue/${parentTicketId}`,
+        {
+          headers: {
+            Authorization: `Basic ${auth}`,
+            'Content-Type': 'application/json',
+          },
+        },
+      );
+
+      if (parentResponse.ok) {
+        const parentData = await parentResponse.json();
+        const cleanedParentData = stripJiraTicketFields(parentData);
+
+        mainTicketData = cleanedParentData;
+        subTaskTicketData = cleanedData;
+      }
+    } else {
+      mainTicketId = ticketId;
+      mainTicketData = cleanedData;
+    }
+
+    return {
+      mainTicketData,
+      subTaskTicketData,
+      mainTicketId,
+      subTaskTicketId,
+    };
+  } catch (error) {
+    console.error(`Error fetching JIRA ticket ${ticketId}:`, error.message);
+    return null;
+  }
+}
+
+/**
+ * Generate a changelog summary using OpenAI
+ * @param {Object} params - Parameters object
+ * @param {Object} params.taskTicketData - The task/subtask ticket data
+ * @param {Object} params.mainTicketData - The main ticket data
+ * @returns {Promise<Object>} - Changelog summary
+ */
+export async function generateChangeLog({ taskTicketData, mainTicketData }) {
+  if (!OPENAI_API_KEY) {
+    console.warn('OpenAI API key not provided. Skipping changelog generation.');
+    return null;
+  }
+
+  if (!taskTicketData || !mainTicketData) return null;
+
+  try {
+    // Determine if this is a subtask by comparing ticket keys
+    const isSubtask = taskTicketData.key !== mainTicketData.key;
+
+    let systemPrompt;
+    let userPrompt;
+
+    if (isSubtask) {
+      // For subtasks, provide context from the main ticket
+      systemPrompt = `You are analyzing a Jira subtask and its parent ticket. Generate a concise summary of what is being implemented in this subtask.
+
+The summary should:
+- Focus on what the subtask is implementing specifically
+- Include context from the parent ticket to provide understanding
+- Be 1-2 sentences maximum
+- Be clear and user-facing (avoid overly technical jargon)
+
+Return your response in this JSON format:
+{
+  "summary": "A concise summary of what is being implemented in the subtask"
+}`;
+
+      userPrompt = JSON.stringify(
+        {
+          mainTicket: mainTicketData,
+          subtask: taskTicketData,
+        },
+        null,
+        2,
+      );
+    } else {
+      // For regular tickets, just summarize the main ticket
+      systemPrompt = `You are analyzing a Jira ticket. Generate a concise summary of what is being implemented.
+
+The summary should:
+- Be 1-2 sentences maximum
+- Be clear and user-facing (avoid overly technical jargon)
+- Capture the main purpose of the ticket
+
+Return your response in this JSON format:
+{
+  "summary": "A concise summary of what is being implemented"
+}`;
+
+      userPrompt = JSON.stringify(mainTicketData, null, 2);
+    }
+
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${OPENAI_API_KEY}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: OPENAI_MODEL,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userPrompt },
+        ],
+        response_format: {
+          type: 'json_schema',
+          json_schema: {
+            name: 'changelog_summary',
+            schema: {
+              type: 'object',
+              properties: {
+                summary: {
+                  type: 'string',
+                  description: 'A concise summary of what is being implemented',
+                },
+              },
+              required: ['summary'],
+              additionalProperties: false,
+            },
+          },
+        },
+        temperature: 0,
+      }),
+    });
+
+    if (!response.ok) {
+      console.error(`Error from OpenAI API: ${response.statusText}`);
+      return null;
+    }
+
+    const data = await response.json();
+    const content = JSON.parse(data.choices[0].message.content);
+
+    // Validate response using Zod schema
+    const validatedResponse = changeLogSummarySchema.parse(content);
+
+    return validatedResponse;
+  } catch (error) {
+    console.error('Error generating changelog summary:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Generate enhanced release notes using OpenAI
+ * @param {Object} ticketData - The JIRA ticket data
+ * @returns {Promise<Object>} - Enhanced release notes
+ */
+
+export async function generateEnhancedReleaseNotes(ticketData) {
+  if (!OPENAI_API_KEY) {
+    console.warn(
+      'OpenAI API key not provided. Skipping release notes enhancement.',
+    );
+    return null;
+  }
+
+  if (!ticketData) return null;
+
+  try {
+    const systemPrompt = `Process the provided JSON from a Jira ticket to generate structured release notes in JSON format.
+Follow this strict schema to generate your response:
+
+{
+  "title": "A concise title for the release note (3-8 words)",
+  "summary": "A brief user-facing summary of changes (max 2 sentences)",
+  "technicalDescription": "Developer-friendly description of technical changes in markdown format (max 5 sentences)",
+  "userFacingDescription": "Provide only if changes made to user interface. Plain-language description of changes from a user perspective in markdown format (max 5 sentences)",
+  "technicalOnly": boolean (true/false whether this change is only technical with no user-visible impact),
+  "changeType": "New" | "Improved" | "Fixed",
+  "changeSize": "Small" | "Medium" | "Large"
+}
+
+When creating your response:
+- Title: Create a concise title summarizing the change (3–8 words). Avoid repeating the Jira ticket title.
+- Summary: Write a maximum two-sentence summary in user-facing language.
+- Technical Description: Use developer-friendly language to explain what changed at the system or code level. Include only if specified: API impacts, architectural changes, or deployment considerations. Format using markdown. Use backticks for code (\`like_this\`), bold for important terms, and line breaks for readability. Avoid headings like Technical Changes
+- User-Facing Description: Provide only if changes are made to the user interface. Use plain language to explain what users will see or benefit from. Include affected UI elements, workflows, or systems. Prefer bullet points if listing multiple effects or changes. Use markdown formatting for clarity.
+- Technical Only: Set to true if the change has no visible effect to end users. Examples for technical only are API changes, refactoring of code or architectual changes that do not have changes to the user interface
+- Change Type: Classify as “New”, “Improved”, or “Fixed”.
+- Change Size: Estimate the impact as “Small”, “Medium”, or “Large”.
+
+For Descriptions:
+Avoid large blocks of text. Break content into short paragraphs or lists. Use markdown consistently: code, bold, italic, and single level bullet lists (- Item). Make your response easy to scan, especially the descriptions. Focus on what changed, how it works, and where it applies.
+Avoid restating the ticket title. Focus on what changed, how it works, and where it applies.
+`;
+
+    const userPrompt = JSON.stringify(ticketData, null, 2);
+
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${OPENAI_API_KEY}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: OPENAI_MODEL,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userPrompt },
+        ],
+        response_format: {
+          type: 'json_schema',
+          json_schema: {
+            name: 'release_notes',
+            schema: {
+              type: 'object',
+              properties: {
+                title: {
+                  type: 'string',
+                  description:
+                    'A concise title for the release note (3-8 words)',
+                },
+                summary: {
+                  type: 'string',
+                  description:
+                    'A brief user-facing summary of changes (max 2 sentences)',
+                },
+                technicalDescription: {
+                  type: 'string',
+                  description:
+                    'Developer-friendly description of technical changes (max 5 sentences)',
+                },
+                userFacingDescription: {
+                  type: 'string',
+                  description:
+                    'Plain-language description of changes from a user perspective (max 5 sentences)',
+                },
+                technicalOnly: {
+                  type: 'boolean',
+                  description:
+                    'Whether this change is technical-only with no user-visible impact',
+                },
+                changeSize: {
+                  type: 'string',
+                  enum: ['Small', 'Medium', 'Large'],
+                  description: 'Size/scope of the change',
+                },
+                changeType: {
+                  type: 'string',
+                  enum: ['New', 'Improved', 'Fixed'],
+                  description: 'Type of change',
+                },
+              },
+              required: [
+                'title',
+                'summary',
+                'technicalOnly',
+                'changeSize',
+                'changeType',
+              ],
+              additionalProperties: false,
+            },
+          },
+        },
+        temperature: 0, // Lower temperature for more structured/predictable responses
+      }),
+    });
+
+    if (!response.ok) {
+      console.error(`Error from OpenAI API: ${response.statusText}`);
+      return null;
+    }
+
+    const data = await response.json();
+
+    const content = JSON.parse(data.choices[0].message.content);
+
+    // Validate response using Zod schema
+    const validatedResponse = openAiResponseSchema.parse(content);
+
+    return validatedResponse;
+  } catch (error) {
+    console.error('Error generating enhanced release notes:', error.message);
+    return null;
+  }
+}
+
+export async function writeYamlFile(mainTicketId, enhancedNotes) {
+  // Create changeset directory if it doesn't exist
+  if (!fs.existsSync(path.join(process.cwd(), '.release-notes'))) {
+    fs.mkdirSync(path.join(process.cwd(), '.release-notes'));
+  }
+
+  const yamlFileName = `${mainTicketId}.yaml`;
+  const yamlFilePath = path.join(CHANGESET_DIR, yamlFileName);
+
+  const yamlContent = yaml.dump(
+    {
+      ticketId: mainTicketId,
+      title: enhancedNotes.title,
+      summary: enhancedNotes.summary,
+      technicalDescription: {
+        __line: enhancedNotes.technicalDescription,
+      },
+      userFacingDescription: {
+        __line: enhancedNotes.userFacingDescription,
+      },
+      technicalOnly: enhancedNotes.technicalOnly,
+      changeSize: enhancedNotes.changeSize,
+      changeType: enhancedNotes.changeType,
+    },
+    {
+      lineWidth: -1, // Don't wrap lines
+      noRefs: true,
+      schema: yaml.DEFAULT_SCHEMA.extend({
+        implicit: [
+          new yaml.Type('tag:yaml.org,2002:str', {
+            kind: 'scalar',
+            instanceOf: Object,
+            resolve: function (object) {
+              return object !== null && object['__line'];
+            },
+            construct: function (object) {
+              return object.__line;
+            },
+            represent: function (object) {
+              return { __line: object.__line };
+            },
+          }),
+        ],
+      }),
+    },
+  );
+
+  // Replace the problematic YAML output with properly formatted literal block scalars
+  const fixedYaml = yamlContent
+    .replace(/technicalDescription: '?(.*?)'?$/m, () => {
+      return `technicalDescription: |\n  ${enhancedNotes.technicalDescription.replace(/\n/g, '\n  ')}`;
+    })
+    .replace(/userFacingDescription: '?(.*?)'?$/m, () => {
+      return `userFacingDescription: |\n  ${enhancedNotes.userFacingDescription.replace(/\n/g, '\n  ')}`;
+    });
+
+  fs.writeFileSync(yamlFilePath, fixedYaml, 'utf8');
+}
+
+export async function getReleaseNotes(ticketId) {
+  const ticketData = await fetchJiraTicket(ticketId);
+
+  if (ticketData) {
+    // Generate enhanced release notes
+    const { mainTicketData, subTaskTicketData, mainTicketId } = ticketData;
+
+    const yamlFileName = `${mainTicketId}.yaml`;
+    const yamlFilePath = path.join(CHANGESET_DIR, yamlFileName);
+
+    if (fs.existsSync(yamlFilePath)) {
+      console.log(
+        `Notes for ticket ${mainTicketId} already exist, loading from file`,
+      );
+      try {
+        const fileContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const enhancedNotes = yaml.load(fileContent);
+        const changeLog = await generateChangeLog({
+          taskTicketData: subTaskTicketData ?? mainTicketData,
+          mainTicketData,
+        });
+        return {
+          yamlFilePath,
+          enhancedNotes,
+          mainTicketId: enhancedNotes.ticketId,
+          summary: changeLog.summary,
+        };
+      } catch (error) {
+        console.error(
+          `Error loading YAML file for ${mainTicketId}:`,
+          error.message,
+        );
+      }
+    } else {
+      const [changeLog, enhancedNotes] = await Promise.all([
+        generateChangeLog({
+          taskTicketData: subTaskTicketData ?? mainTicketData,
+          mainTicketData,
+        }),
+        generateEnhancedReleaseNotes(mainTicketData),
+      ]);
+
+      if (enhancedNotes) {
+        await writeYamlFile(mainTicketId, enhancedNotes);
+        return {
+          yamlFilePath,
+          enhancedNotes,
+          mainTicketId,
+          summary: changeLog.summary,
+        };
+      } else {
+        throw new Error(`Cannot generate release notes for ${mainTicketId}`);
+      }
+    }
+  }
+}

package/src/changeset/validate.js

@@ -2,20 +2,9 @@ import fs from 'fs';
 import path from 'path';
 import { $ } from 'zx';
 
-import { isMonoRepo, setGitInfo } from '../next/util.js';
+import { setGitInfo } from '../next/util.js';
 import { versionStatus } from './version.js';
 
-const CHANGESET_DIR = '.changeset';
-
-function areArraysEqualIgnoringOrder(arr1, arr2) {
-  if (arr1.length !== arr2.length) return false;
-
-  const sortedA = [...arr1].sort();
-  const sortedB = [...arr2].sort();
-
-  return sortedA.every((element, index) => element === sortedB[index]);
-}
-
 export async function validateChangesets() {
   await setGitInfo();
   const destBranch = process.env.BITBUCKET_PR_DESTINATION_BRANCH;

package/src/changeset/version.js

@@ -1,10 +1,19 @@
 import { setGitInfo } from '../next/util.js';
 import { $ } from 'zx';
-import fs from 'fs';
+import fs, { readFileSync } from 'fs';
 import { updateComponentVersion } from '../next/jira.js';
 import { findJiraTicketId } from './util.js';
 import { revertBaseBranch, updateBaseBranch } from './changeset-config.js';
 import semver from 'semver';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const getPackageVersion = () => {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const packageJsonPath = join(__dirname, '../../package.json');
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  return packageJson.version;
+};
 
 const changeSetPackage = `{
   "name": "changeset-package",
@@ -18,11 +27,23 @@ const changeSetPackage = `{
   "license": "ISC",
   "dependencies": {},
   "devDependencies": {
-    "@changesets/cli": "^2.27.10"
+    "@changesets/cli": "^2.27.10",
+    "@docupace/pipeline": "${getPackageVersion()}"
   }
 }
 `;
 
+export async function loadChangesetOutput() {
+  const outputPath = './changeset-output.json';
+  const jsonOutput = JSON.parse(await fs.promises.readFile(outputPath, 'utf8'));
+  return jsonOutput;
+}
+
+async function removeChangesetOutput() {
+  const outputPath = './changeset-output.json';
+  await fs.promises.rm(outputPath);
+}
+
 export function toShortVersion(version) {
   const parsed = semver.parse(version);
   if (!parsed) return null;
@@ -41,7 +62,6 @@ export async function versionStatus(sinceBranch) {
   // Read the file and parse JSON
   const jsonOutput = JSON.parse(await fs.promises.readFile(outputPath, 'utf8'));
 
-  await fs.promises.rm(outputPath);
   return jsonOutput.releases;
 }
 
@@ -68,6 +88,8 @@ export async function versionCommand(closeVersion = false) {
     revertBaseBranch(originalBaseBranch);
     await $`pnpm changeset version`;
 
+    await removeChangesetOutput();
+
     return releases;
   } catch {
     revertBaseBranch(originalBaseBranch);

package/src/index.mjs

@@ -0,0 +1,2 @@
+import changelogCanny from './changeset/changelog.js';
+export default changelogCanny;

package/src/lib/merge-driver.js

@@ -2,12 +2,8 @@
 
 import fs from 'fs';
 import { execSync } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
 
 // Get __dirname equivalent in ESM
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
 
 /**
  * Default merge logic function - can be overridden
@@ -16,7 +12,7 @@ const __dirname = path.dirname(__filename);
  * @returns {string} - The merged content
  * @throws {Error} - If the conflict cannot be automatically merged
  */
-export function defaultMergeLogic(headContent, branchContent) {
+export function defaultMergeLogic() {
   // Default implementation - throws error
   // Users should provide their own implementation
   throw new Error(

package/src/merge/cli-merge-all.js

@@ -78,7 +78,7 @@ function readMergeConfig(verbose = false) {
  * Extract repository name from git URL
  */
 function getRepoName(gitUrl) {
-  const match = gitUrl.match(/\/([^\/]+)\.git$/);
+  const match = gitUrl.match(/\/([^/]+)\.git$/);
   return match ? match[1] : gitUrl.split('/').pop().replace('.git', '');
 }
 
@@ -459,7 +459,6 @@ async function mergeAll(verbose = false) {
     console.log(`═══════════════════════════════════════`);
 
     allResults.forEach((result, index) => {
-      const { from, to } = result.mergeBranch;
       const status = result.success ? '✅' : '⚠️';
       console.log(`\n${status} Merge branch set ${index + 1}:`);