@skitterbyte/skitterspec-jira 0.0.0-stage → 1.0.0

package/src/lines-diff.js

@@ -0,0 +1,114 @@
+'use strict'
+
+/**
+ * A minimal line diff — just enough for `update` to say what it skipped.
+ *
+ * `update` reports a file it kept as `customized (kept)` and nothing else, so
+ * there is no way to learn WHICH upstream changes you declined without diffing
+ * against `node_modules` by hand. That is how a real behavioural change (the
+ * lifecycle skills learning to commit their own edits) went unnoticed through an
+ * upgrade in the field.
+ *
+ * Zero dependencies on purpose: this package ships with none, and `diff(1)` is
+ * not a portable guarantee. An LCS over lines is a few dozen lines of code and
+ * the inputs are markdown files of a few hundred lines.
+ */
+
+// Longest-common-subsequence walk over two line arrays, as a flat op list.
+// `t` is ' ' (context), '-' (only in `a`) or '+' (only in `b`).
+function diffOps(a, b) {
+  const n = a.length
+  const m = b.length
+  // dp[i][j] = LCS length of a[i..] and b[j..], flattened.
+  const dp = new Int32Array((n + 1) * (m + 1))
+  const at = (i, j) => i * (m + 1) + j
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[at(i, j)] = a[i] === b[j] ? dp[at(i + 1, j + 1)] + 1 : Math.max(dp[at(i + 1, j)], dp[at(i, j + 1)])
+    }
+  }
+
+  const ops = []
+  let i = 0
+  let j = 0
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      ops.push({ t: ' ', line: a[i], a: i, b: j })
+      i++
+      j++
+    } else if (dp[at(i + 1, j)] >= dp[at(i, j + 1)]) {
+      ops.push({ t: '-', line: a[i], a: i, b: j })
+      i++
+    } else {
+      ops.push({ t: '+', line: b[j], a: i, b: j })
+      j++
+    }
+  }
+  while (i < n) {
+    ops.push({ t: '-', line: a[i], a: i, b: j })
+    i++
+  }
+  while (j < m) {
+    ops.push({ t: '+', line: b[j], a: i, b: j })
+    j++
+  }
+  return ops
+}
+
+// Group the ops into unified-diff hunks, each carrying `context` unchanged lines
+// either side of a run of changes. Runs closer together than 2×context merge, as
+// `diff -u` does, so a cluster of edits reads as one hunk.
+function toHunks(ops, context) {
+  const changed = ops.map((o) => o.t !== ' ')
+  const hunks = []
+  let k = 0
+  while (k < ops.length) {
+    if (!changed[k]) {
+      k++
+      continue
+    }
+    let start = Math.max(0, k - context)
+    let end = k
+    // Extend while the next change is near enough to keep in the same hunk.
+    for (let p = k; p < ops.length; p++) {
+      if (changed[p]) end = p
+      else if (p - end > context * 2) break
+    }
+    end = Math.min(ops.length - 1, end + context)
+
+    const body = ops.slice(start, end + 1)
+    const aStart = body[0].a + 1
+    const bStart = body[0].b + 1
+    const aLen = body.filter((o) => o.t !== '+').length
+    const bLen = body.filter((o) => o.t !== '-').length
+    hunks.push(
+      [`@@ -${aStart},${aLen} +${bStart},${bLen} @@`, ...body.map((o) => `${o.t}${o.line}`)].join('\n'),
+    )
+    k = end + 1
+  }
+  return hunks
+}
+
+/**
+ * Diff `a` (what is on disk) against `b` (what the package ships).
+ *
+ * `added`/`removed` count the lines an update WOULD add and remove — the summary
+ * printed beside a kept file. `hunks` are unified-diff blocks for `--diff`.
+ *
+ * @param {string|string[]} a
+ * @param {string|string[]} b
+ * @param {{context?:number}} [opts]
+ * @returns {{added:number, removed:number, hunks:string[]}}
+ */
+function linesDiff(a, b, { context = 3 } = {}) {
+  const A = Array.isArray(a) ? a : String(a).split('\n')
+  const B = Array.isArray(b) ? b : String(b).split('\n')
+  const ops = diffOps(A, B)
+  return {
+    added: ops.filter((o) => o.t === '+').length,
+    removed: ops.filter((o) => o.t === '-').length,
+    hunks: toHunks(ops, context),
+  }
+}
+
+module.exports = { linesDiff }

package/src/prompts.js

@@ -0,0 +1,129 @@
+'use strict'
+
+/**
+ * Interactive setup flow for `skitterspec init`, built on the `prompts`
+ * (terkelg) library. Only required from the TTY branch of the CLI — the
+ * non-interactive path (flags / --yes / CI) never loads this module, so the
+ * test suite never imports the interactive UI.
+ *
+ * `isolationSeed` pre-fills the per-spec isolation question. Returns
+ * `{ isolation, mode }` — `mode` is only asked when isolation is enabled, and
+ * is `'worktree'` otherwise (the value the config defaults to anyway).
+ */
+
+async function promptSetup({ isolationSeed = false, gatingSeed = false } = {}) {
+  const prompts = require('prompts')
+
+  let cancelled = false
+  const onCancel = () => {
+    cancelled = true
+    return false // stop the prompt chain
+  }
+
+  const questions = [
+    {
+      type: 'confirm',
+      name: 'isolation',
+      message: 'Enable per-spec isolation — build each spec on its own branch?',
+      initial: isolationSeed,
+    },
+    {
+      // Only reachable when isolation was accepted: `prev` is the previous
+      // answer, and returning null skips the question entirely.
+      type: (prev) => (prev ? 'select' : null),
+      name: 'mode',
+      message: 'Where should a spec be built?',
+      hint: '- this is the trade, not a preference',
+      initial: 0,
+      choices: [
+        {
+          title: 'Its own worktree (default)',
+          value: 'worktree',
+          description: 'several specs at once, main left free — one terminal session per spec',
+        },
+        {
+          title: 'The checkout you are in',
+          value: 'checkout',
+          description: 'one spec at a time, no second session — your terminal follows the work',
+        },
+      ],
+    },
+    {
+      // Orthogonal to isolation, so it is asked unconditionally rather than
+      // nested under it — a project can adopt either, both, or neither.
+      type: 'confirm',
+      name: 'gating',
+      message: 'Record a release-gating decision on each spec — flag, or land live?',
+      initial: gatingSeed,
+    },
+  ]
+
+  const ans = await prompts(questions, { onCancel })
+  if (cancelled) throw new Error('Setup cancelled')
+
+  // Anything other than an explicit 'checkout' resolves to the default, so a
+  // skipped or cancelled-into-default answer can never select the mode that
+  // puts a spec's work in the primary checkout.
+  return {
+    isolation: Boolean(ans.isolation),
+    mode: ans.mode === 'checkout' ? 'checkout' : 'worktree',
+    gating: Boolean(ans.gating),
+  }
+}
+
+/**
+ * Interactive confirm for removing leftover release tooling on `update`. Returns
+ * true only on an explicit yes; a cancel (Ctrl-C / Esc) resolves to false so the
+ * default is always to keep the files.
+ */
+async function confirmRemoveReleaseTooling() {
+  const prompts = require('prompts')
+  const ans = await prompts(
+    {
+      type: 'confirm',
+      name: 'remove',
+      message: 'Found release tooling (now in @skitterbyte/skittership). Remove it here?',
+      initial: false,
+    },
+    { onCancel: () => false },
+  )
+  return Boolean(ans.remove)
+}
+
+/**
+ * Interactive choice when `init` finds an already-set-up repo. Returns one of
+ * `leave` | `resync` | `reset`. Defaults to (and cancels to) `leave` — the safe
+ * no-op — and asks a second confirm before `reset` (destructive to managed files).
+ */
+async function promptExistingSetup() {
+  const prompts = require('prompts')
+  const { action } = await prompts(
+    {
+      type: 'select',
+      name: 'action',
+      message: 'This project already has skitterspec set up. What would you like to do?',
+      initial: 0,
+      choices: [
+        { title: 'Leave alone — make no changes', value: 'leave' },
+        { title: 'Resync — update managed files to the latest, keep my edits', value: 'resync' },
+        { title: 'Start again — reset the scaffolding (your specs & config are kept)', value: 'reset' },
+      ],
+    },
+    { onCancel: () => {} },
+  )
+  if (action === 'reset') {
+    const { confirm } = await prompts(
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Start again overwrites managed skills/rules. Your specs and config are untouched. Continue?',
+        initial: false,
+      },
+      { onCancel: () => false },
+    )
+    if (!confirm) return 'leave'
+  }
+  return action || 'leave'
+}
+
+module.exports = { promptSetup, confirmRemoveReleaseTooling, promptExistingSetup }

package/src/vendor/jira/adf.js

@@ -0,0 +1,414 @@
+'use strict'
+
+/**
+ * Markdown ⇄ ADF — the two halves of Jira Cloud's description dialect.
+ *
+ * Jira Cloud's REST v3 stores rich text as the Atlassian Document Format, a
+ * JSON tree — there is no markdown field. The engine's projections are
+ * markdown, so the adapter renders outbound text with `mdToAdf` and reduces
+ * every read-back with `adfToText`; ADF never escapes the adapter
+ * (`api.js` normalises at the boundary).
+ *
+ * FIDELITY IS WORD-LEVEL, BY DESIGN. Every comparison downstream — verify's
+ * `compareStored`, the snapshot's `descriptionStream`, remote-edit detection —
+ * reduces text through the dialect's `canonicalForCompare` and then strips to
+ * word characters (sync-core `src/verify.js`). So the round-trip contract this
+ * module owes is: `stream(adfToText(mdToAdf(md))) === stream(md)` — no word
+ * gained, none lost, in order. Byte-level markdown fidelity is deliberately
+ * NOT promised: Jira normalises its own tree on save anyway.
+ *
+ * The subset is what spec projections actually contain: headings, paragraphs,
+ * bullet/ordered lists (nested), task checklists, inline strong/em/code/links,
+ * fenced code, blockquotes, and top-level tables. Checklists render as ADF
+ * task lists (`taskList`/`taskItem`) so they are live checkboxes in Jira; the
+ * mirror is still read-only — a box ticked in Jira is overwritten on the next
+ * push, exactly like every other mirrored field.
+ *
+ * Pure string/JSON transforms: no I/O, no clock, no randomness (task-item
+ * localIds are sequential — Jira rewrites them on save and nothing here reads
+ * them back).
+ */
+
+// --- inline: markdown text → ADF text nodes ---------------------------------
+
+const text = (value, marks) => {
+  const node = { type: 'text', text: value }
+  if (marks && marks.length) node.marks = marks
+  return node
+}
+
+// Earliest match wins among: `code`, **strong**, *em*, [text](url). A `*`
+// needs a non-space neighbour to open (so `2 * 3` stays literal), mirroring
+// the flanking rule the rest of the toolchain uses.
+function inlineNodes(src, marks = []) {
+  const out = []
+  let rest = String(src == null ? '' : src)
+  while (rest.length) {
+    const candidates = [
+      { at: rest.indexOf('`'), kind: 'code' },
+      { at: rest.indexOf('**'), kind: 'strong' },
+      { at: rest.search(/\*(?!\*)(?=\S)/), kind: 'em' },
+      { at: rest.search(/\[[^\]]*\]\([^)]*\)/), kind: 'link' },
+    ]
+      .filter((c) => c.at >= 0)
+      .sort((a, b) => a.at - b.at)
+    if (!candidates.length) {
+      out.push(text(rest, marks))
+      break
+    }
+    const { at, kind } = candidates[0]
+    if (at > 0) out.push(text(rest.slice(0, at), marks))
+    rest = rest.slice(at)
+    if (kind === 'code') {
+      const close = rest.indexOf('`', 1)
+      if (close < 0) {
+        out.push(text(rest, marks))
+        break
+      }
+      const body = rest.slice(1, close)
+      // ADF puts `code` in an exclusion group: Jira rejects the WHOLE document
+      // when a text node carries `code` beside strong/em (or any mark other
+      // than `link`, the one companion the schema allows). So inherited
+      // emphasis is DROPPED here rather than merged — `**x `+'`'+`y`+'`'+` z**`
+      // renders y as plain code, exactly as Jira's own editor treats the same
+      // markdown — which loses emphasis, never words (fidelity is word-level
+      // by design; see the module header).
+      const kept = marks.filter((m) => m.type === 'link')
+      if (body) out.push(text(body, [...kept, { type: 'code' }]))
+      rest = rest.slice(close + 1)
+    } else if (kind === 'strong') {
+      const close = rest.indexOf('**', 2)
+      if (close < 0) {
+        out.push(text(rest, marks))
+        break
+      }
+      out.push(...inlineNodes(rest.slice(2, close), [...marks, { type: 'strong' }]))
+      rest = rest.slice(close + 2)
+    } else if (kind === 'em') {
+      const m = /^\*(?!\*)([^*]+)\*/.exec(rest)
+      if (!m) {
+        out.push(text(rest.slice(0, 1), marks))
+        rest = rest.slice(1)
+        continue
+      }
+      out.push(...inlineNodes(m[1], [...marks, { type: 'em' }]))
+      rest = rest.slice(m[0].length)
+    } else {
+      const m = /^\[([^\]]*)\]\(([^)]*)\)/.exec(rest)
+      out.push(...inlineNodes(m[1], [...marks, { type: 'link', attrs: { href: m[2] } }]))
+      rest = rest.slice(m[0].length)
+    }
+  }
+  return out.length ? out : [text('', marks)]
+}
+
+const paragraph = (md) => ({ type: 'paragraph', content: inlineNodes(md) })
+
+// --- blocks: markdown lines → ADF nodes -------------------------------------
+
+const LIST_RE = /^(\s*)([-*+]|\d+\.)\s+(?:\[([ xX])\]\s+)?(.*)$/
+const FENCE_RE = /^\s*```(.*)$/
+const HEADING_RE = /^(#{1,6})\s+(.*)$/
+const TABLE_SEP_RE = /^\s*\|[\s:|-]+\|\s*$/
+
+// One list ITEM's parsed shape, before nesting is resolved.
+function parseListLines(lines) {
+  const items = []
+  for (const line of lines) {
+    const m = LIST_RE.exec(line)
+    if (m) {
+      items.push({
+        indent: m[1].length,
+        ordered: /^\d+\.$/.test(m[2]),
+        check: m[3] === undefined ? null : m[3] !== ' ',
+        text: m[4],
+      })
+    } else if (items.length) {
+      // Continuation line: part of the previous item's text (soft wrap).
+      items[items.length - 1].text += ' ' + line.trim()
+    }
+  }
+  return items
+}
+
+// Fold flat items into nested ADF lists by indent. Task items become an ADF
+// taskList (live checkboxes); plain items a bulletList/orderedList.
+function buildList(items, taskIds, options) {
+  const root = { children: [] }
+  const stack = [{ indent: -1, node: root }]
+  for (const item of items) {
+    while (stack.length > 1 && item.indent <= stack[stack.length - 1].indent) stack.pop()
+    const parent = stack[stack.length - 1].node
+    const entry = { ...item, children: [] }
+    parent.children.push(entry)
+    stack.push({ indent: item.indent, node: entry })
+  }
+
+  function render(children) {
+    const groups = []
+    for (const child of children) {
+      const kind = child.check !== null ? 'task' : child.ordered ? 'ordered' : 'bullet'
+      const last = groups[groups.length - 1]
+      if (last && last.kind === kind) last.items.push(child)
+      else groups.push({ kind, items: [child] })
+    }
+    return groups.map((group) => {
+      if (group.kind === 'task' && options && options.taskLists === false) {
+        // The fallback switch: should the live smoke find a surface where Jira
+        // drops `taskList` nodes, checklists render as plain bullets carrying
+        // their checkbox as text — words preserved, interactivity forfeited.
+        return {
+          type: 'bulletList',
+          content: group.items.map((item) => ({
+            type: 'listItem',
+            content: [paragraph(`[${item.check ? 'x' : ' '}] ${item.text}`), ...render(item.children)],
+          })),
+        }
+      }
+      if (group.kind === 'task') {
+        return {
+          type: 'taskList',
+          attrs: { localId: `tasks-${++taskIds.n}` },
+          content: group.items.map((item) => ({
+            type: 'taskItem',
+            attrs: { localId: `task-${++taskIds.n}`, state: item.check ? 'DONE' : 'TODO' },
+            content: inlineNodes(item.text),
+            // ADF task items cannot nest lists; a nested child is rare enough in
+            // a projection that flattening it to a following sibling is fine.
+          })).concat(group.items.flatMap((item) => render(item.children)).flat()),
+        }
+      }
+      const type = group.kind === 'ordered' ? 'orderedList' : 'bulletList'
+      return {
+        type,
+        content: group.items.map((item) => ({
+          type: 'listItem',
+          content: [paragraph(item.text), ...render(item.children)],
+        })),
+      }
+    })
+  }
+  return render(root.children)
+}
+
+function buildTable(rows) {
+  const split = (line) => {
+    const cells = []
+    let cur = ''
+    let code = false
+    for (const ch of line.replace(/^\s*\|/, '').replace(/\|\s*$/, '')) {
+      if (ch === '`') code = !code
+      if (ch === '|' && !code) {
+        cells.push(cur.trim())
+        cur = ''
+        continue
+      }
+      cur += ch
+    }
+    cells.push(cur.trim())
+    return cells
+  }
+  const bodyRows = rows.filter((r) => !TABLE_SEP_RE.test(r))
+  return {
+    type: 'table',
+    content: bodyRows.map((row, i) => ({
+      type: 'tableRow',
+      content: split(row).map((cell) => ({
+        type: i === 0 ? 'tableHeader' : 'tableCell',
+        content: [paragraph(cell)],
+      })),
+    })),
+  }
+}
+
+/**
+ * Markdown → an ADF document (`{ version: 1, type: 'doc', content: [...] }`).
+ */
+function mdToAdf(md, options) {
+  const lines = String(md == null ? '' : md).replace(/\r\n/g, '\n').split('\n')
+  const content = []
+  const taskIds = { n: 0 }
+  let i = 0
+  while (i < lines.length) {
+    const line = lines[i]
+    if (!line.trim()) {
+      i++
+      continue
+    }
+    const fence = FENCE_RE.exec(line)
+    if (fence) {
+      const body = []
+      i++
+      while (i < lines.length && !FENCE_RE.test(lines[i])) body.push(lines[i++])
+      if (i < lines.length) i++
+      const node = { type: 'codeBlock', content: body.length ? [text(body.join('\n'))] : [] }
+      if (fence[1].trim()) node.attrs = { language: fence[1].trim() }
+      content.push(node)
+      continue
+    }
+    const heading = HEADING_RE.exec(line)
+    if (heading) {
+      content.push({ type: 'heading', attrs: { level: heading[1].length }, content: inlineNodes(heading[2]) })
+      i++
+      continue
+    }
+    if (/^\s*>/.test(line)) {
+      const quoted = []
+      while (i < lines.length && /^\s*>/.test(lines[i])) quoted.push(lines[i++].replace(/^\s*> ?/, ''))
+      content.push({ type: 'blockquote', content: mdToAdf(quoted.join('\n')).content })
+      continue
+    }
+    if (/^\s*\|.*\|\s*$/.test(line) && TABLE_SEP_RE.test(lines[i + 1] || '')) {
+      const rows = []
+      while (i < lines.length && /^\s*\|.*\|\s*$/.test(lines[i])) rows.push(lines[i++])
+      content.push(buildTable(rows))
+      continue
+    }
+    if (LIST_RE.test(line)) {
+      const block = []
+      while (i < lines.length && lines[i].trim() && (LIST_RE.test(lines[i]) || /^\s{2,}/.test(lines[i]))) {
+        block.push(lines[i++])
+      }
+      content.push(...buildList(parseListLines(block), taskIds, options))
+      continue
+    }
+    if (/^\s*([-*_])\s*\1\s*\1[\s\-*_]*$/.test(line)) {
+      content.push({ type: 'rule' })
+      i++
+      continue
+    }
+    // Paragraph: consecutive plain lines are one soft-wrapped paragraph.
+    const para = []
+    while (
+      i < lines.length &&
+      lines[i].trim() &&
+      !FENCE_RE.test(lines[i]) &&
+      !HEADING_RE.test(lines[i]) &&
+      !LIST_RE.test(lines[i]) &&
+      !/^\s*>/.test(lines[i]) &&
+      !/^\s*\|.*\|\s*$/.test(lines[i])
+    ) {
+      para.push(lines[i++].trim())
+    }
+    content.push(paragraph(para.join(' ')))
+  }
+  return { version: 1, type: 'doc', content }
+}
+
+// --- ADF → text --------------------------------------------------------------
+
+function inlineText(nodes) {
+  let out = ''
+  for (const node of nodes || []) {
+    if (node.type === 'text') {
+      let t = node.text || ''
+      for (const mark of node.marks || []) {
+        if (mark.type === 'strong') t = `**${t}**`
+        else if (mark.type === 'em') t = `*${t}*`
+        else if (mark.type === 'code') t = `\`${t}\``
+        else if (mark.type === 'link') t = `[${t}](${(mark.attrs && mark.attrs.href) || ''})`
+      }
+      out += t
+    } else if (node.type === 'hardBreak') {
+      out += '\n'
+    } else if (node.type === 'mention') {
+      out += (node.attrs && node.attrs.text) || ''
+    } else if (node.type === 'emoji') {
+      out += (node.attrs && node.attrs.text) || ''
+    } else if (node.content) {
+      out += inlineText(node.content)
+    }
+  }
+  return out
+}
+
+function listToText(node, indent, ordered) {
+  const lines = []
+  let n = 0
+  for (const item of node.content || []) {
+    n++
+    const marker = ordered ? `${n}.` : '-'
+    const inner = []
+    const nested = []
+    for (const child of item.content || []) {
+      if (child.type === 'paragraph') inner.push(inlineText(child.content))
+      else nested.push(child)
+    }
+    lines.push(`${indent}${marker} ${inner.join(' ')}`)
+    for (const child of nested) lines.push(blockToText(child, indent + '  '))
+  }
+  return lines.join('\n')
+}
+
+function blockToText(node, indent = '') {
+  switch (node.type) {
+    case 'heading':
+      return `${indent}${'#'.repeat((node.attrs && node.attrs.level) || 1)} ${inlineText(node.content)}`
+    case 'paragraph':
+      return indent + inlineText(node.content)
+    case 'bulletList':
+      return listToText(node, indent, false)
+    case 'orderedList':
+      return listToText(node, indent, true)
+    case 'taskList': {
+      const lines = []
+      for (const item of node.content || []) {
+        if (item.type === 'taskItem') {
+          const mark = item.attrs && item.attrs.state === 'DONE' ? 'x' : ' '
+          lines.push(`${indent}- [${mark}] ${inlineText(item.content)}`)
+        } else {
+          lines.push(blockToText(item, indent + '  '))
+        }
+      }
+      return lines.join('\n')
+    }
+    case 'codeBlock': {
+      const lang = (node.attrs && node.attrs.language) || ''
+      return `${indent}\`\`\`${lang}\n${inlineText(node.content)}\n${indent}\`\`\``
+    }
+    case 'blockquote':
+      return (node.content || [])
+        .map((child) => blockToText(child, indent))
+        .join('\n\n')
+        .split('\n')
+        .map((l) => `${indent}> ${l}`)
+        .join('\n')
+    case 'table': {
+      const rows = []
+      for (const row of node.content || []) {
+        const cells = (row.content || []).map((cell) => inlineText((cell.content || [])).replace(/\n/g, ' '))
+        rows.push(`${indent}| ${cells.join(' | ')} |`)
+        if (!rows.seenSep && row.content && row.content[0] && row.content[0].type === 'tableHeader') {
+          rows.push(`${indent}|${' -- |'.repeat(row.content.length)}`)
+          rows.seenSep = true
+        }
+      }
+      return rows.join('\n')
+    }
+    case 'rule':
+      return `${indent}---`
+    case 'mediaGroup':
+    case 'mediaSingle':
+      return ''
+    default:
+      // Unknown block: render its children rather than dropping words —
+      // losing content silently is the one failure verify exists to catch.
+      return node.content ? node.content.map((child) => blockToText(child, indent)).join('\n\n') : ''
+  }
+}
+
+/**
+ * An ADF document (or fragment) → markdown-ish text. Accepts anything
+ * plausible: a full doc, a content array, a string (returned as-is), or null.
+ */
+function adfToText(adf) {
+  if (adf == null) return ''
+  if (typeof adf === 'string') return adf
+  const content = Array.isArray(adf) ? adf : adf.content || []
+  return content
+    .map((node) => blockToText(node))
+    .filter((s) => s !== '')
+    .join('\n\n')
+}
+
+module.exports = { mdToAdf, adfToText }