confluence-cli 2.1.6 → 2.1.8

package/lib/html-to-markdown.js

@@ -1,3 +1,5 @@
+const { fenceLength, cleanupWithFences } = require('./markdown-cleanup');
+
 const NAMED_ENTITIES = {
   aring: 'å', auml: 'ä', ouml: 'ö',
   eacute: 'é', egrave: 'è', ecirc: 'ê', euml: 'ë',
@@ -165,58 +167,7 @@ function htmlToMarkdown(html) {
 
   markdown = markdown.replace(/&([a-zA-Z]+);/g, (match, name) => NAMED_ENTITIES[name] || match);
 
-  // Split on fenced code boundaries so cleanup rules (indent stripping,
-  // multi-space collapsing) don't mangle indentation-sensitive code.
-  // Backreference matches dynamically-sized fences emitted above when the
-  // body itself contains backticks.
-  const segments = splitOnFences(markdown);
-  markdown = segments
-    .map((seg, i) => (i % 2 === 1 ? seg : cleanupOutsideFence(seg)))
-    .join('');
-  markdown = markdown.trim();
-
-  return markdown;
-}
-
-// CommonMark allows fenced code with N≥3 backticks where the body contains
-// no run of N+ backticks. Pick the smallest N satisfying both so a code
-// block whose payload itself contains ``` does not close its own fence.
-function fenceLength(body) {
-  let max = 0;
-  const runs = body.match(/`+/g);
-  if (runs) {
-    for (const r of runs) if (r.length > max) max = r.length;
-  }
-  return Math.max(3, max + 1);
-}
-
-function splitOnFences(text) {
-  // CommonMark: a fence opens on a line that starts with up to 3 spaces
-  // followed by 3+ backticks, and closes on a line of equal-length
-  // backticks followed only by whitespace. Anchoring to line boundaries
-  // (^ / $ with m flag) prevents prose backticks (e.g. <p>literal ``` x</p>)
-  // from being mis-paired with real fence boundaries.
-  const result = [];
-  const re = /^ {0,3}(`{3,})[^\n]*\n[\s\S]*?\n {0,3}\1[\t ]*$/gm;
-  let lastIdx = 0;
-  let m;
-  while ((m = re.exec(text)) !== null) {
-    result.push(text.slice(lastIdx, m.index));
-    result.push(m[0]);
-    lastIdx = m.index + m[0].length;
-  }
-  result.push(text.slice(lastIdx));
-  return result;
-}
-
-function cleanupOutsideFence(text) {
-  let out = text;
-  out = out.replace(/[ \t]+$/gm, '');
-  out = out.replace(/^[ \t]+(?!([`>]|[*+-] |\d+[.)] ))/gm, '');
-  out = out.replace(/^(#{1,6}[^\n]+)\n(?!\n)/gm, '$1\n\n');
-  out = out.replace(/\n\s*\n\s*\n+/g, '\n\n');
-  out = out.replace(/[ \t]+/g, ' ');
-  return out;
+  return cleanupWithFences(markdown);
 }
 
 module.exports = {

package/lib/markdown-cleanup.js

@@ -0,0 +1,80 @@
+// Shared fence-aware markdown cleanup for storage-walker and html-to-markdown.
+// Both converters need the same set of operations:
+//   1. Size opening/closing fences against the entity-decoded code body so a
+//      payload containing literal backticks (or numeric entities that decode
+//      to backticks) does not close its own fence.
+//   2. Split the post-conversion text on fenced code boundaries using a
+//      CommonMark line-anchored matcher so prose `\`\`\`` cannot be mis-paired
+//      with a real fence opening.
+//   3. Apply a 5-step whitespace cleanup chain only outside fenced code.
+//
+// Keeping these helpers in one place prevents the converters from drifting
+// apart again — see issue #149 for the history.
+
+// CommonMark allows fenced code with N≥3 backticks where the body contains
+// no run of N+ backticks. Pick the smallest N satisfying both. Caller must
+// pass an entity-decoded body — numeric entity refs like ``` are
+// backticks once decoded, so sizing before decode would leave the fence
+// breakable when the entities resolve.
+function fenceLength(decodedBody) {
+  let max = 0;
+  const runs = decodedBody.match(/`+/g);
+  if (runs) {
+    for (const r of runs) if (r.length > max) max = r.length;
+  }
+  return Math.max(3, max + 1);
+}
+
+// Split text on fenced code boundaries. Returns an alternating sequence of
+// segments where even indices are outside-fence text and odd indices are
+// full fenced blocks (delimiters included).
+//
+// CommonMark: a fence opens on a line of up to 3 spaces + 3+ backticks and
+// closes on a line of equal-length backticks followed only by whitespace.
+// Anchoring to line boundaries (^ / $ with the m flag) prevents prose
+// backticks (e.g. a paragraph documenting markdown syntax) from being
+// mis-paired with a real fence opening.
+function splitOnFences(text) {
+  const result = [];
+  const re = /^ {0,3}(`{3,})[^\n]*\n[\s\S]*?\n {0,3}\1[\t ]*$/gm;
+  let lastIdx = 0;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    result.push(text.slice(lastIdx, m.index));
+    result.push(m[0]);
+    lastIdx = m.index + m[0].length;
+  }
+  result.push(text.slice(lastIdx));
+  return result;
+}
+
+// Whitespace cleanup safe to apply to text that sits outside fenced code.
+// Strips trailing whitespace, strips leading whitespace except where it
+// signals a list/blockquote/inline-code marker, ensures a blank line after
+// headers, collapses 3+ blank lines, and squashes runs of inline whitespace.
+function cleanupOutsideFence(text) {
+  let out = text;
+  out = out.replace(/[ \t]+$/gm, '');
+  out = out.replace(/^[ \t]+(?!([`>]|[*+-] |\d+[.)] ))/gm, '');
+  out = out.replace(/^(#{1,6}[^\n]+)\n(?!\n)/gm, '$1\n\n');
+  out = out.replace(/\n\s*\n\s*\n+/g, '\n\n');
+  out = out.replace(/[ \t]+/g, ' ');
+  return out;
+}
+
+// Apply outside-fence cleanup while leaving fenced code untouched, then
+// trim leading and trailing whitespace from the joined result.
+function cleanupWithFences(text) {
+  const segments = splitOnFences(text);
+  return segments
+    .map((seg, i) => (i % 2 === 1 ? seg : cleanupOutsideFence(seg)))
+    .join('')
+    .trim();
+}
+
+module.exports = {
+  fenceLength,
+  splitOnFences,
+  cleanupOutsideFence,
+  cleanupWithFences,
+};

package/lib/storage-walker.js

@@ -1,5 +1,6 @@
 const { parseDocument } = require('htmlparser2');
 const { decodeHTML } = require('entities');
+const { fenceLength, cleanupWithFences } = require('./markdown-cleanup');
 
 const DEFAULT_MAX_DEPTH = 256;
 
@@ -125,6 +126,8 @@ class StorageWalker {
       return '**' + this.walkNodes(node.children) + '**';
     case 'em': case 'i':
       return '*' + this.walkNodes(node.children) + '*';
+    case 's': case 'del':
+      return '~~' + this.walkNodes(node.children) + '~~';
     case 'code':
       return '`' + this.walkNodes(node.children) + '`';
     case 'br':
@@ -260,7 +263,8 @@ class StorageWalker {
     const lang = langParam ? this.getTextContent(langParam) : '';
     const plainBody = this.findChildByName(node, 'ac:plain-text-body');
     const code = plainBody ? this.getRawText(plainBody) : '';
-    return `\n\`\`\`${lang}\n${code}\n\`\`\`\n`;
+    const fence = '`'.repeat(fenceLength(code));
+    return `\n${fence}${lang}\n${code}\n${fence}\n`;
   }
 
   handleCallout(node, marker) {
@@ -296,7 +300,8 @@ class StorageWalker {
   handleMermaid(node) {
     const plainBody = this.findChildByName(node, 'ac:plain-text-body');
     const code = plainBody ? this.getRawText(plainBody).trim() : '';
-    return `\n\`\`\`mermaid\n${code}\n\`\`\`\n`;
+    const fence = '`'.repeat(fenceLength(code));
+    return `\n${fence}mermaid\n${code}\n${fence}\n`;
   }
 
   handleInclude(node) {
@@ -351,9 +356,17 @@ class StorageWalker {
 
   handleImage(node) {
     const riAttachment = this.findChildByName(node, 'ri:attachment');
-    if (!riAttachment) return '';
-    const filename = decodeEntities(riAttachment.attribs['ri:filename'] || '');
-    return `![${filename}](${this.attachmentsDir}/${filename})`;
+    if (riAttachment) {
+      const filename = decodeEntities(riAttachment.attribs['ri:filename'] || '');
+      return `![${filename}](${this.attachmentsDir}/${filename})`;
+    }
+    const riUrl = this.findChildByName(node, 'ri:url');
+    if (riUrl) {
+      const url = decodeEntities(riUrl.attribs['ri:value'] || '');
+      if (!url) return '';
+      return `![](${url})`;
+    }
+    return '';
   }
 
   handleAcLink(node) {
@@ -465,24 +478,7 @@ class StorageWalker {
   }
 
   cleanup(text) {
-    // Split on fenced code boundaries so cleanup rules (indent stripping,
-    // multi-space collapsing) don't mangle indentation-sensitive code.
-    // Walker only emits triple-backtick fences (see code/mermaid macros).
-    const segments = text.split(/(```[\s\S]*?```)/g);
-    const cleaned = segments
-      .map((seg, i) => (i % 2 === 1 ? seg : this._cleanupOutsideFence(seg)))
-      .join('');
-    return cleaned.trim();
-  }
-
-  _cleanupOutsideFence(text) {
-    let out = text;
-    out = out.replace(/[ \t]+$/gm, '');
-    out = out.replace(/^[ \t]+(?!([`>]|[*+-] |\d+[.)] ))/gm, '');
-    out = out.replace(/^(#{1,6}[^\n]+)\n(?!\n)/gm, '$1\n\n');
-    out = out.replace(/\n\s*\n\s*\n+/g, '\n\n');
-    out = out.replace(/[ \t]+/g, ' ');
-    return out;
+    return cleanupWithFences(text);
   }
 }
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "confluence-cli",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "confluence-cli",
-      "version": "2.1.6",
+      "version": "2.1.8",
       "license": "MIT",
       "dependencies": {
         "axios": "^1.15.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "confluence-cli",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "A command-line interface for Atlassian Confluence with page creation and editing capabilities",
   "main": "index.js",
   "bin": {