@docupace/pipeline 1.0.39-matttest.36 → 1.0.39-matttest.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docupace/pipeline",
-  "version": "1.0.39-matttest.36",
+  "version": "1.0.39-matttest.39",
   "description": "",
   "main": "index.js",
   "type": "module",

package/src/changeset/create.js

@@ -1,12 +1,12 @@
-import { $ } from 'zx';
 import OpenAI from 'openai';
 import z from 'zod';
 import { zodResponseFormat } from 'openai/helpers/zod';
 import fs from 'fs';
 import path from 'path';
-import { getAllAppPackages, getAllPackages, isMonoRepo } from '../next/util.js';
 import inquirer from 'inquirer';
 import { getMainPackage, getPackage } from './util.js';
+import { getPackageNames } from './package-util.js';
+import { execSync } from 'child_process';
 
 async function createChangesetDirectory() {
   try {
@@ -24,11 +24,18 @@ async function createChangesetDirectory() {
  * Gets the current git branch name
  */
 async function getCurrentBranch() {
-  const branchName = (await $`git branch --show-current`).stdout.trim();
-  console.log(`Current branch: ${branchName}`);
-  return branchName;
+  try {
+    const branchName = execSync('git branch --show-current', {
+      encoding: 'utf8',
+      shell: true,
+    }).trim();
+    console.log(`Current branch: ${branchName}`);
+    return branchName;
+  } catch (error) {
+    console.error('Error getting current branch:', error.message);
+    throw error;
+  }
 }
-
 /**
  * Extracts a Jira ticket ID from a branch name
  */
@@ -103,14 +110,14 @@ async function generateReleaseNotes(jiraTicketData) {
 /**
  * Writes the changeset file
  */
-async function writeChangesetFile(
-  componentName,
-  jiraTicketId,
-  changeType,
-  summary,
-) {
+async function writeChangesetFile(packages, jiraTicketId, changeType, summary) {
+  // Generate the YAML frontmatter for multiple packages
+  const packageEntries = packages
+    .map((pkg) => `'${pkg.name}': ${changeType}`)
+    .join('\n');
+
   const changesetContent = `---
-"${componentName}": ${changeType}
+${packageEntries}
 ---
 
 ${summary} [${jiraTicketId}]
@@ -127,31 +134,47 @@ ${summary} [${jiraTicketId}]
  */
 
 export async function createChangeset() {
-  if (isMonoRepo()) {
-    const allPackages = await getAllPackages();
+  const packages = getPackageNames();
+
+  if (packages.length > 1) {
+    const allPackages = packages;
     const response = await inquirer.prompt([
       {
-        type: 'list',
-        name: 'package',
-        message: 'Which package do you want to generate changesetfor?',
-        choices: allPackages.map((appPackage) => appPackage.name),
+        type: 'checkbox',
+        name: 'packages',
+        message: 'Which packages do you want to generate changesets for?',
+        choices: allPackages.map((appPackage) => ({
+          name: appPackage.name,
+          value: appPackage.name,
+        })),
+        validate: (input) => {
+          if (input.length === 0) {
+            return 'Please select at least one package.';
+          }
+          return true;
+        },
       },
     ]);
 
-    const selectedPackage = allPackages.find(
-      (appPackage) => appPackage.name == response.package,
+    const selectedPackages = allPackages.filter((appPackage) =>
+      response.packages.includes(appPackage.name),
+    );
+
+    // Get package contents for all selected packages
+    const selectedPackageContents = await Promise.all(
+      selectedPackages.map(async (selectedPackage) => {
+        return await getPackage(selectedPackage.path);
+      }),
     );
 
-    const selectedPackageContent = await getPackage(selectedPackage.path);
-    await createChangesetForPackage(selectedPackageContent);
+    await createChangesetForPackage(selectedPackageContents);
   } else {
     const mainPackage = await getMainPackage();
-    await createChangesetForPackage(mainPackage);
+    await createChangesetForPackage([mainPackage]);
   }
 }
 
-export async function createChangesetForPackage(mainPackage) {
-  const componentName = mainPackage.name;
+export async function createChangesetForPackage(packages) {
   try {
     // Step 1: Get the current branch name
     const branchName = await getCurrentBranch();
@@ -171,10 +194,10 @@ export async function createChangesetForPackage(mainPackage) {
     console.log(`Change type: ${change_type}`);
     console.log(`Release note: ${summary}`);
 
-    // Step 5: Create a changeset .md file
-    await writeChangesetFile(componentName, jiraTicketId, change_type, summary);
+    // Step 5: Create a changeset .md file for all packages
+    await writeChangesetFile(packages, jiraTicketId, change_type, summary);
 
-    console.log('Done!');
+    console.log('Changeset created successfully!');
   } catch (err) {
     console.error(`Error: ${err.message}`);
     process.exit(1);

package/src/changeset/package-util.js

@@ -0,0 +1,86 @@
+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;
+}