@docupace/pipeline 1.0.39-newrelease.8 → 1.0.39

package/src/changeset/openai.js

@@ -1,437 +0,0 @@
-#!/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'),
-});
-
-/**
- * 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 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 ticketId =
-      ticketData.mainTicketId || ticketData.mainTicketData?.key || 'unknown';
-
-    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.hasOwnProperty('__line');
-            },
-            construct: function (object) {
-              return object.__line;
-            },
-            predicate: function (object) {
-              return object.hasOwnProperty('__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, (match, p1) => {
-      return `technicalDescription: |\n  ${enhancedNotes.technicalDescription.replace(/\n/g, '\n  ')}`;
-    })
-    .replace(/userFacingDescription: '?(.*?)'?$/m, (match, p1) => {
-      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);
-        return {
-          yamlFilePath,
-          enhancedNotes,
-          mainTicketId: enhancedNotes.ticketId,
-        };
-      } catch (error) {
-        console.error(
-          `Error loading YAML file for ${mainTicketId}:`,
-          error.message,
-        );
-      }
-    }
-
-    const enhancedNotes = await generateEnhancedReleaseNotes({
-      mainTicketData,
-      subTaskTicketData,
-      mainTicketId,
-    });
-
-    if (enhancedNotes) {
-      await writeYamlFile(mainTicketId, enhancedNotes);
-      return { yamlFilePath, enhancedNotes, mainTicketId };
-    } else {
-      throw new Error(`Cannot generate release notes for ${mainTicketId}`);
-    }
-  }
-}

package/src/changeset/package-util.js

@@ -1,86 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-export function getPackageNames(rootPath = '.') {
-  const appsDir = path.join(rootPath, 'apps');
-  const packagesDir = path.join(rootPath, 'packages');
-  const rootPackageJson = path.join(rootPath, 'package.json');
-
-  // Check if this is a monorepo (has apps and/or packages directories)
-  const hasAppsDir =
-    fs.existsSync(appsDir) && fs.statSync(appsDir).isDirectory();
-  const hasPackagesDir =
-    fs.existsSync(packagesDir) && fs.statSync(packagesDir).isDirectory();
-
-  if (hasAppsDir || hasPackagesDir) {
-    // This is a monorepo
-    const packages = [];
-
-    // Get packages from apps directory
-    if (hasAppsDir) {
-      const appsPackages = getPackagesFromDirectory(appsDir);
-      packages.push(...appsPackages);
-    }
-
-    // Get packages from packages directory
-    if (hasPackagesDir) {
-      const packagesPackages = getPackagesFromDirectory(packagesDir);
-      packages.push(...packagesPackages);
-    }
-
-    return packages;
-  } else {
-    // This is not a monorepo, return single package
-    if (fs.existsSync(rootPackageJson)) {
-      try {
-        const packageJson = JSON.parse(
-          fs.readFileSync(rootPackageJson, 'utf8'),
-        );
-        return packageJson.name
-          ? [{ name: packageJson.name, path: rootPath }]
-          : [];
-      } catch (error) {
-        console.error('Error reading root package.json:', error);
-        return [];
-      }
-    }
-    return [];
-  }
-}
-
-function getPackagesFromDirectory(dirPath) {
-  const packages = [];
-
-  try {
-    const items = fs.readdirSync(dirPath);
-
-    for (const item of items) {
-      const itemPath = path.join(dirPath, item);
-      const packageJsonPath = path.join(itemPath, 'package.json');
-
-      // Check if item is a directory and has package.json
-      if (
-        fs.statSync(itemPath).isDirectory() &&
-        fs.existsSync(packageJsonPath)
-      ) {
-        try {
-          const packageJson = JSON.parse(
-            fs.readFileSync(packageJsonPath, 'utf8'),
-          );
-          if (packageJson.name) {
-            packages.push({
-              name: packageJson.name,
-              path: itemPath,
-            });
-          }
-        } catch (error) {
-          console.error(`Error reading package.json in ${itemPath}:`, error);
-        }
-      }
-    }
-  } catch (error) {
-    console.error(`Error reading directory ${dirPath}:`, error);
-  }
-
-  return packages;
-}

package/src/changeset/util.js

@@ -1,43 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-
-async function fileExists(filePath) {
-  try {
-    await fs.promises.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-export async function getMainPackage() {
-  const mainModulePath = process.cwd();
-  return getPackage(mainModulePath);
-}
-
-export async function getPackage(mainModulePath) {
-  if (mainModulePath) {
-    const packageJsonPath = path.join(mainModulePath, 'package.json');
-    if (await fileExists(packageJsonPath)) {
-      const fileContent = await fs.promises.readFile(packageJsonPath, 'utf-8');
-      const packageJson = JSON.parse(fileContent);
-      return packageJson;
-    }
-  }
-  throw new Error('Main package.json not found');
-}
-
-/**
- * Locates and extracts a JIRA Ticket ID from a given string.
- * <p>
- * The JIRA Ticket ID is expected to follow the pattern of uppercase letters (at least two) followed by a hyphen and digits (e.g., DC-1234, INFP-9).
- * @param str the string to search for a JIRA ticket ID
- * @returns {JIRA-TicketID|null}
- */
-export function findJiraTicketId(str) {
-  if (!str) {
-    return null;
-  }
-  const regex = /([A-Z]{2,}-\d+)/;
-  const matches = str.match(regex);
-  return matches ? matches[0] : null;
-}

package/src/changeset/version.js

@@ -1,102 +0,0 @@
-import { setGitInfo } from '../next/util.js';
-import { $ } from 'zx';
-import fs from 'fs';
-import { updateComponentVersion } from '../next/jira.js';
-import { findJiraTicketId } from './util.js';
-
-const changeSetPackage = `{
-  "name": "changeset-package",
-  "version": "1.0.0",
-  "description": "",
-  "scripts": {
-  },
-  "type": "module",
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {},
-  "devDependencies": {
-    "@changesets/cli": "^2.27.10",
-    "@docupace/pipeline": "1.0.39-newrelease.7"
-  }
-}
-`;
-
-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 async function versionStatus(sinceBranch) {
-  const outputPath = './changeset-output.json';
-
-  if (sinceBranch) {
-    await $`pnpm changeset status --output=${outputPath} --since=${sinceBranch}`;
-  } else {
-    await $`pnpm changeset status --output=${outputPath}`;
-  }
-
-  // Read the file and parse JSON
-  const jsonOutput = JSON.parse(await fs.promises.readFile(outputPath, 'utf8'));
-
-  return jsonOutput.releases;
-}
-
-export async function versionCommand(closeVersion = false) {
-  console.log('📦 Running Changeset versioning...');
-  await setGitInfo();
-  await $`mv package.json package.json.bak`;
-  await $`mv pnpm-lock.yaml pnpm-lock.yaml.bak`;
-  await fs.promises.writeFile('package.json', changeSetPackage);
-  await $`pnpm install`;
-  await $`rm package.json pnpm-lock.yaml`;
-  await $`mv package.json.bak package.json`;
-  await $`mv pnpm-lock.yaml.bak pnpm-lock.yaml`;
-  if (closeVersion) {
-    await $`pnpm changeset pre exit`;
-  }
-
-  try {
-    const releases = await versionStatus();
-
-    await $`pnpm changeset version`;
-
-    await removeChangesetOutput();
-
-    return releases;
-  } catch {
-    return [];
-  }
-}
-
-export async function updateJiraWithVersion(releases) {
-  const lastCommit = (await $`git log -1 --pretty=%B`).stdout.trim();
-  console.log(`Last commit '${lastCommit}' being processed to get Jira ticket`);
-
-  const jiraTicketId = findJiraTicketId(lastCommit);
-
-  // If we have all the necessary data, update the component version in Jira
-  if (jiraTicketId) {
-    for (const release of releases) {
-      try {
-        await updateComponentVersion(
-          jiraTicketId,
-          release.name,
-          release.newVersion,
-        );
-      } catch (error) {
-        console.error(
-          `Failed to update Jira component version: ${error.message}`,
-        );
-      }
-    }
-  }
-
-  console.log('✅ Changeset versioning complete.');
-}

package/src/index.mjs

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

package/src/next/logger.js

@@ -1,17 +0,0 @@
-import { $ as original$ } from 'zx';
-
-// Wrapped version of $
-export const $ = async (strings, ...values) => {
-  const command = strings.reduce(
-    (acc, str, i) => acc + str + (values[i] ?? ''),
-    '',
-  );
-  console.log(`Executing: ${command}`);
-  try {
-    const result = await original$(strings, ...values);
-    return result;
-  } catch (error) {
-    console.error(`Error executing: ${command}`, error);
-    throw error;
-  }
-};