@docupace/pipeline 1.0.60-alpha.1 → 1.0.61-alpha.0

package/eslint.config.js

@@ -10,7 +10,7 @@ export default [
       globals: {
         ...globals.browser,
         ...globals.node, // Add Node.js globals
-      },g
+      },
     },
   },
   pluginJs.configs.recommended,

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@docupace/pipeline",
-  "version": "1.0.60-alpha.1",
-  "description": "",
+  "version": "1.0.61-alpha.0",
   "main": "index.js",
   "type": "module",
   "bin": {
     "dp-changeset-cli": "src/changeset/cli.js",
     "dp-next-cli": "src/next/cli.js",
-    "dp-auth0-cli": "src/auth0/cli.js"
+    "dp-auth0-cli": "src/auth0/cli.js",
+    "dp-merge-cli": "src/merge/cli.js"
   },
   "keywords": [
     "bash"

package/src/changeset/changelog-wiki.js

@@ -0,0 +1,313 @@
+// npm i axios
+import axios from 'axios';
+import { readFileSync } from 'fs';
+import { getPackageNames } from './package-util.js';
+import path from 'path';
+import { toShortVersion } from './version.js';
+
+/**
+ * Required env:
+ *   CONFLUENCE_BASE_URL   e.g. "https://docupacellc.atlassian.net/wiki"
+ *   CONFLUENCE_EMAIL      e.g. "you@docupace.com"
+ *   CONFLUENCE_API_TOKEN  Atlassian API token
+ */
+const BASE_URL = process.env.CONFLUENCE_BASE_URL;
+const EMAIL = process.env.CONFLUENCE_EMAIL;
+const API_TOKEN = process.env.CONFLUENCE_API_TOKEN;
+
+const getHttpService = () =>
+  axios.create({
+    baseURL: BASE_URL.replace(/\/+$/, ''),
+    auth: { username: EMAIL, password: API_TOKEN },
+  });
+
+/** ---------- ADF builder: Markdown macro ---------- */
+function adfMarkdown(markdown) {
+  return {
+    type: 'doc',
+    version: 1,
+    content: [
+      {
+        type: 'extension',
+        attrs: {
+          layout: 'default',
+          extensionType: 'com.atlassian.confluence.macro.core',
+          extensionKey: 'markdown',
+          parameters: {
+            macroParams: {
+              sourceType: { value: 'MacroBody' },
+              darkmode: { value: 'auto' },
+              syntax: { value: 'Markdown' },
+              attachmentPageId: { value: '' },
+              attachmentId: { value: '' },
+              url: { value: '' },
+              __bodyContent: { value: markdown },
+            },
+          },
+        },
+      },
+    ],
+  };
+}
+
+/** ---------- API helpers (v2) ---------- */
+
+// get a page (v2) by id
+async function getPage(pageId) {
+  const { data } = await getHttpService().get(`/api/v2/pages/${pageId}`);
+  return data;
+}
+
+// list child pages (paginated) and return *all* children
+async function listChildPages(parentId) {
+  const all = [];
+  let next = `/api/v2/pages/${parentId}/children?limit=200`;
+
+  while (next) {
+    const { data } = await getHttpService().get(next);
+    if (Array.isArray(data.results)) all.push(...data.results);
+    next = data?._links?.next || null;
+  }
+  return all;
+}
+
+// find a direct child page by exact title
+async function findChildByTitle(parentId, title) {
+  const kids = await listChildPages(parentId);
+  return kids.find((p) => (p.title || '').trim() === title.trim()) || null;
+}
+
+// create a child page under a parent
+async function createChildPage({
+  parentId,
+  spaceId,
+  title,
+  adf,
+  message = 'Create via API',
+}) {
+  const payload = {
+    status: 'current',
+    title,
+    spaceId,
+    parentId,
+    body: {
+      atlas_doc_format: {
+        value: adf,
+        representation: 'atlas_doc_format',
+      },
+    },
+    version: { number: 1, message, minorEdit: false },
+  };
+  const { data } = await getHttpService().post(`/api/v2/pages`, payload);
+  return data;
+}
+
+// update an existing page (replace body + optionally title)
+async function updatePage({
+  page,
+  title = page.title,
+  adf,
+  message = 'Update via API',
+}) {
+  if (!page.version) {
+    page = await getPage(page.id);
+  }
+  const payload = {
+    id: page.id,
+    status: 'current',
+    title,
+    spaceId: page.spaceId,
+    body: {
+      atlas_doc_format: {
+        value: adf,
+        representation: 'atlas_doc_format',
+      },
+    },
+    version: {
+      number: page.version.number + 1,
+      message,
+      minorEdit: false,
+    },
+  };
+  const { data } = await getHttpService().put(
+    `/api/v2/pages/${page.id}`,
+    payload,
+  );
+  return data;
+}
+
+const childPagesAdf = {
+  type: 'doc',
+  version: 1,
+  content: [
+    {
+      type: 'extension',
+      attrs: {
+        extensionType: 'com.atlassian.confluence.macro.core',
+        extensionKey: 'children',
+        layout: 'default',
+        parameters: {
+          macroParams: {
+            allChildren: { value: 'true' },
+          },
+          macroMetadata: {
+            macroId: { value: '9ea4beb6-ac0a-42d7-baf1-e8e6eca01bfd' },
+            schemaVersion: { value: '2' },
+            title: { value: 'Child pages' },
+          },
+        },
+        localId: '4890f00c-c519-4947-a60c-0c3b7e1c7b72',
+      },
+    },
+  ],
+};
+
+/** ---------- Main upsert workflow ---------- */
+
+/**
+ * Upsert release notes at: Versions(parent) -> Version(title) -> Component(title)
+ *
+ * @param {object} args
+ * @param {string} args.versionsParentId - Page ID of the "Versions" page
+ * @param {string} args.versionTitle     - e.g. "Version 1"
+ * @param {string} args.componentTitle   - e.g. "Component A"
+ * @param {string} args.markdown         - Release notes markdown for the component page
+ *
+ * @returns {Promise<{versionPage:any, componentPage:any}>}
+ */
+export async function upsertReleaseNotes({
+  versionsParentId,
+  version,
+  component,
+  markdown,
+  group,
+}) {
+  if (!BASE_URL || !EMAIL || !API_TOKEN) {
+    throw new Error(
+      'Missing required env: CONFLUENCE_BASE_URL, CONFLUENCE_EMAIL, CONFLUENCE_API_TOKEN',
+    );
+  }
+
+  if (!versionsParentId || !version || !component) {
+    throw new Error(
+      'versionsParentId, versionTitle, and componentTitle are required',
+    );
+  }
+
+  if (!markdown || markdown.trim() === '') {
+    throw new Error('markdown content is required and cannot be empty');
+  }
+
+  // 1) fetch the parent to get spaceId
+  const parent = await getPage(versionsParentId);
+  const spaceId = parent.spaceId;
+
+  const versionTitle = `Docupace ${group} - Version ${version}`;
+  // 2) ensure Version page under parent
+  let versionPage = await findChildByTitle(parent.id, versionTitle);
+  if (!versionPage) {
+    versionPage = await createChildPage({
+      parentId: parent.id,
+      spaceId,
+      title: versionTitle,
+      adf: JSON.stringify(childPagesAdf),
+      message: `Create version page ${versionTitle}`,
+    });
+  }
+
+  const componentTitle = `${versionTitle} - ${component} Changelog`;
+
+  // 3) ensure Component page under Version
+  let componentPage = await findChildByTitle(versionPage.id, componentTitle);
+  const adf = adfMarkdown(markdown);
+
+  if (!componentPage) {
+    componentPage = await createChildPage({
+      parentId: versionPage.id,
+      spaceId,
+      title: componentTitle,
+      adf: JSON.stringify(adf),
+      message: `Create component page ${componentTitle}`,
+    });
+  } else {
+    // update existing component page with new markdown
+    componentPage = await updatePage({
+      page: componentPage,
+      title: componentTitle,
+      adf: JSON.stringify(adf),
+      message: `Update component page ${componentTitle}`,
+    });
+  }
+
+  return { versionPage, componentPage };
+}
+
+/**
+ * Upsert release notes from a markdown file
+ *
+ * @param {object} args
+ * @param {string} args.versionTitle     - e.g. "Version 1"
+ * @param {string} args.componentTitle   - e.g. "Component A"
+ * @param {string} args.markdownFile     - Path to markdown file
+ *
+ * @returns {Promise<{versionPage:any, componentPage:any}>}
+ */
+export async function upsertReleaseNotesFromFile({
+  version,
+  component,
+  markdownFile,
+  group,
+}) {
+  if (!group) {
+    throw new Error('changelog.group must be specified in package.json');
+  }
+
+  const versionsParentId =
+    process.env[`CONFLUENCE_${group.toUpperCase()}_PARENT_ID`];
+
+  if (!versionsParentId) {
+    throw new Error(
+      `CONFLUENCE_${group.toUpperCase()}_PARENT_ID environment variable is required`,
+    );
+  }
+
+  if (!markdownFile) {
+    throw new Error('markdownFile is required');
+  }
+
+  // Read markdown content from file
+  const markdown = readFileSync(markdownFile, 'utf8');
+
+  return upsertReleaseNotes({
+    versionsParentId,
+    version,
+    component,
+    markdown,
+    group,
+  });
+}
+
+export async function updateWikiWithVersion(releases) {
+  const packageNames = getPackageNames();
+  console.log(releases);
+
+  const promises = packageNames
+    .filter(
+      (packageName) =>
+        releases.find((release) => release.name == packageName.name) &&
+        packageName.content?.changelog?.component,
+    )
+    .map(async (packageName) => {
+      const release = releases.find(
+        (release) => release.name == packageName.name,
+      );
+      await upsertReleaseNotesFromFile({
+        version: toShortVersion(release.newVersion),
+        component: packageName.content.changelog?.component,
+        markdownFile: path.join(packageName.path, 'CHANGELOG.md'),
+        group: packageName.content.changelog?.group,
+      });
+    });
+
+  await Promise.all(promises);
+}

package/src/changeset/cli.js

@@ -10,6 +10,10 @@ import {
   versionCommand,
 } from './version.js';
 import { createChangeset } from './create.js';
+import {
+  updateWikiWithVersion,
+  upsertReleaseNotesFromFile,
+} from './changelog-wiki.js';
 
 dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
 
@@ -93,6 +97,11 @@ async function commitTag() {
     await $`node -p "require('./package.json').version"`
   ).stdout.trim();
 
+  if (process.env.IS_DEV) {
+    console.log(`Simulate commit of version ${newVersion}`);
+    return;
+  }
+
   const defaultBranch = process.env.BITBUCKET_BRANCH;
 
   await $`git commit -m "Version bump to ${newVersion} and changelog"`;
@@ -136,6 +145,7 @@ program
     console.log('📦 Running all steps...');
     const releases = await versionCommand();
     await updateJiraWithVersion(releases);
+    await updateWikiWithVersion(releases);
     await commitTagCommand(releases);
   });
 
@@ -187,5 +197,41 @@ program
     await createChangeset();
   });
 
+program
+  .command('upload-wiki')
+  .description('Upload release notes from markdown file to Confluence')
+  .requiredOption(
+    '-v, --version <version>',
+    'Version title (e.g., "Version 1.0")',
+  )
+  .requiredOption(
+    '-c, --component <component>',
+    'Component title (e.g., "Component A")',
+  )
+  .requiredOption('-f, --file <file>', 'Path to markdown file')
+  .requiredOption('-g, --group <group>', 'Group of release notes')
+
+  .action(async (options) => {
+    try {
+      console.log('📤 Uploading release notes to Confluence...');
+      const { versionPage, componentPage } = await upsertReleaseNotesFromFile({
+        version: options.version,
+        component: options.component,
+        markdownFile: options.file,
+        group: options.group,
+      });
+
+      console.log('✅ Successfully uploaded to Confluence');
+      console.log('Version page:', versionPage._links?.webui || versionPage.id);
+      console.log(
+        'Component page:',
+        componentPage._links?.webui || componentPage.id,
+      );
+    } catch (error) {
+      console.error('❌ Error uploading to Confluence:', error.message);
+      process.exit(1);
+    }
+  });
+
 // Parse arguments
 program.parse(args);

package/src/changeset/create.js

@@ -110,8 +110,17 @@ async function generateReleaseNotes(jiraTicketData) {
 /**
  * Writes the changeset file
  */
-async function writeChangesetFile(packages, jiraTicketId, changeType, summary) {
-  // Generate the YAML frontmatter for multiple packages
+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');
@@ -120,9 +129,10 @@ async function writeChangesetFile(packages, jiraTicketId, changeType, summary) {
 ${packageEntries}
 ---
 
-${summary} [${jiraTicketId}]
+${text}
 `;
-  const changesetFile = `./.changeset/${jiraTicketId}.md`;
+
+  const changesetFile = `./.changeset/${filename}.md`;
 
   await createChangesetDirectory();
   await fs.promises.writeFile(changesetFile, changesetContent);
@@ -195,7 +205,7 @@ export async function createChangesetForPackage(packages) {
     console.log(`Release note: ${summary}`);
 
     // Step 5: Create a changeset .md file for all packages
-    await writeChangesetFile(packages, jiraTicketId, change_type, summary);
+    await writeJiraChangesetFile(packages, jiraTicketId, change_type, summary);
 
     console.log('Changeset created successfully!');
   } catch (err) {

package/src/changeset/package-util.js

@@ -37,7 +37,7 @@ export function getPackageNames(rootPath = '.') {
           fs.readFileSync(rootPackageJson, 'utf8'),
         );
         return packageJson.name
-          ? [{ name: packageJson.name, path: rootPath }]
+          ? [{ name: packageJson.name, path: rootPath, content: packageJson }]
           : [];
       } catch (error) {
         console.error('Error reading root package.json:', error);
@@ -71,6 +71,7 @@ function getPackagesFromDirectory(dirPath) {
             packages.push({
               name: packageJson.name,
               path: itemPath,
+              content: packageJson,
             });
           }
         } catch (error) {

package/src/lib/merge-driver.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+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
+ * @param {string} headContent - The content from HEAD (current branch)
+ * @param {string} branchContent - The content from the incoming branch
+ * @returns {string} - The merged content
+ * @throws {Error} - If the conflict cannot be automatically merged
+ */
+export function defaultMergeLogic(headContent, branchContent) {
+  // Default implementation - throws error
+  // Users should provide their own implementation
+  throw new Error(
+    'No merge logic provided - please pass a custom merge function',
+  );
+}
+
+/**
+ * Main merge driver function
+ * @param {string} filePath - Path to the file with conflicts
+ * @param {Function} customMergeLogic - Custom merge function (optional)
+ * @returns {Promise<{success: boolean, totalConflicts: number, resolvedConflicts: number, hasUnresolvedConflicts: boolean}>}
+ */
+export async function mergeDriver(filePath, customMergeLogic = null) {
+  // Use provided merge logic or fall back to default
+  const mergeLogic = customMergeLogic || defaultMergeLogic;
+
+  if (!filePath) {
+    throw new Error('File path is required');
+  }
+
+  // Check if file exists
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  console.log(`Processing conflicts in: ${filePath}`);
+
+  // Read the file content
+  let fileContent;
+  try {
+    fileContent = fs.readFileSync(filePath, 'utf8');
+  } catch (error) {
+    throw new Error(`Error reading file: ${error.message}`);
+  }
+
+  // Split content into lines for processing
+  const lines = fileContent.split('\n');
+  const resultLines = [];
+
+  // Track merge state
+  let hasUnresolvedConflicts = false;
+  let totalConflicts = 0;
+  let resolvedConflicts = 0;
+
+  // State variables for parsing
+  let inConflict = false;
+  let headLines = [];
+  let branchLines = [];
+  let currentSection = null; // 'head' or 'branch'
+
+  // Process each line
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.startsWith('<<<<<<<')) {
+      // Start of conflict marker
+      inConflict = true;
+      currentSection = 'head';
+      headLines = [];
+      branchLines = [];
+      totalConflicts++;
+    } else if (inConflict && line.startsWith('=======')) {
+      // Middle of conflict - switch from HEAD to branch
+      currentSection = 'branch';
+    } else if (inConflict && line.startsWith('>>>>>>>')) {
+      // End of conflict marker - attempt to merge
+      const headContent = headLines.join('\n');
+      const branchContent = branchLines.join('\n');
+
+      try {
+        // Call custom merge logic
+        const mergedContent = mergeLogic(headContent, branchContent);
+
+        // Add merged content to result
+        if (mergedContent !== null && mergedContent !== undefined) {
+          resultLines.push(mergedContent);
+          resolvedConflicts++;
+          console.log(`✓ Resolved conflict #${totalConflicts}`);
+        }
+      } catch (error) {
+        // Cannot merge this conflict - keep original conflict markers
+        hasUnresolvedConflicts = true;
+
+        console.log(
+          `✗ Could not resolve conflict #${totalConflicts}: ${error.message}`,
+        );
+
+        // Preserve the original conflict
+        resultLines.push(`<<<<<<< HEAD`);
+        resultLines.push(headContent);
+        resultLines.push('=======');
+        resultLines.push(branchContent);
+        resultLines.push(`>>>>>>> branch`);
+      }
+
+      // Reset conflict state
+      inConflict = false;
+      currentSection = null;
+      headLines = [];
+      branchLines = [];
+    } else if (inConflict) {
+      // Inside conflict - collect lines
+      if (currentSection === 'head') {
+        headLines.push(line);
+      } else if (currentSection === 'branch') {
+        branchLines.push(line);
+      }
+    } else {
+      // Normal line outside of conflict
+      resultLines.push(line);
+    }
+  }
+
+  // Write the result back to the file
+  const resultContent = resultLines.join('\n');
+  try {
+    fs.writeFileSync(filePath, resultContent, 'utf8');
+    console.log(`\nFile updated: ${filePath}`);
+  } catch (error) {
+    throw new Error(`Error writing file: ${error.message}`);
+  }
+
+  // Summary
+  console.log('\n--- Merge Summary ---');
+  console.log(`Total conflicts found: ${totalConflicts}`);
+  console.log(`Conflicts resolved: ${resolvedConflicts}`);
+  console.log(`Conflicts remaining: ${totalConflicts - resolvedConflicts}`);
+
+  // If all conflicts were resolved, stage the file
+  if (!hasUnresolvedConflicts && totalConflicts > 0) {
+    try {
+      execSync(`git add "${filePath}"`, { stdio: 'inherit' });
+      console.log(
+        `\n✓ All conflicts resolved! File has been staged with 'git add'.`,
+      );
+    } catch (error) {
+      console.error(`\nWarning: Could not stage file: ${error.message}`);
+      console.log('You may need to run "git add" manually.');
+    }
+  } else if (hasUnresolvedConflicts) {
+    console.log(`\n⚠ Some conflicts could not be resolved automatically.`);
+    console.log('Please review and resolve the remaining conflicts manually.');
+  } else if (totalConflicts === 0) {
+    console.log('\nNo conflicts found in the file.');
+  }
+
+  // Return result object for programmatic use
+  return {
+    success: !hasUnresolvedConflicts,
+    totalConflicts,
+    resolvedConflicts,
+    hasUnresolvedConflicts,
+    filePath,
+  };
+}
+
+/**
+ * Process multiple files with the same merge logic
+ * @param {string[]} filePaths - Array of file paths to process
+ * @param {Function} customMergeLogic - Custom merge function
+ * @returns {Promise<Array>} - Array of results for each file
+ */
+export async function mergeMultipleFiles(filePaths, customMergeLogic) {
+  const results = [];
+
+  for (const filePath of filePaths) {
+    try {
+      const result = await mergeDriver(filePath, customMergeLogic);
+      results.push(result);
+    } catch (error) {
+      console.error(`Error processing ${filePath}: ${error.message}`);
+      results.push({
+        success: false,
+        error: error.message,
+        filePath,
+      });
+    }
+  }
+
+  return results;
+}
+
+// Default export for convenience
+export default mergeDriver;