@ingeniomaps/cauce 0.1.0

package/engine/integrations/providers/jira.js

@@ -0,0 +1,164 @@
+'use strict'
+
+// Adaptador Jira: lectura y normalización, sin escritura remota.
+
+const JIRA_KEY = /^[A-Z][A-Z0-9_]*-\d+$/
+
+function validateConfig(config, errors) {
+  if (typeof config.enabled !== 'boolean') errors.push('jira: enabled debe ser boolean')
+  if (config.enabled && !/^https:\/\/[^/]+$/.test(config.baseUrl || '')) {
+    errors.push('jira: baseUrl debe ser HTTPS sin path final')
+  }
+  if (config.enabled && !String(config.jql || '').trim()) errors.push('jira: falta jql')
+  if (!['basic', 'bearer'].includes(config.auth && config.auth.type)) {
+    errors.push('jira: auth.type debe ser basic|bearer')
+  }
+  if (!config.auth || !config.auth.tokenEnv) errors.push('jira: falta auth.tokenEnv')
+  if (config.auth && config.auth.type === 'basic' && !config.auth.emailEnv) {
+    errors.push('jira: basic exige auth.emailEnv')
+  }
+  if (config.writeBack !== false) {
+    errors.push('jira: writeBack debe permanecer false; no existe un ejecutor remoto aprobado')
+  }
+  if (config.timeoutMs !== undefined
+    && (!Number.isInteger(config.timeoutMs) || config.timeoutMs < 1_000)) {
+    errors.push('jira: timeoutMs debe ser un entero de al menos 1000 ms')
+  }
+  if (config.maxPages !== undefined
+    && (!Number.isInteger(config.maxPages) || config.maxPages < 1)) {
+    errors.push('jira: maxPages debe ser un entero positivo')
+  }
+  if (config.candidateAssigneeEnv
+    && !/^[A-Z][A-Z0-9_]*$/.test(config.candidateAssigneeEnv)) {
+    errors.push('jira: candidateAssigneeEnv debe nombrar una variable de entorno')
+  }
+}
+
+function adfToMarkdown(node) {
+  if (!node) return ''
+  if (typeof node === 'string') return node
+  if (Array.isArray(node)) return node.map(adfToMarkdown).join('')
+  const children = adfToMarkdown(node.content || [])
+  switch (node.type) {
+    case 'doc': return children.trim()
+    case 'text': {
+      let value = node.text || ''
+      for (const mark of node.marks || []) {
+        if (mark.type === 'strong') value = `**${value}**`
+        if (mark.type === 'em') value = `_${value}_`
+        if (mark.type === 'code') value = `\`${value}\``
+        if (mark.type === 'link') value = `[${value}](${mark.attrs && mark.attrs.href})`
+      }
+      return value
+    }
+    case 'hardBreak': return '\n'
+    case 'paragraph': return `${children}\n\n`
+    case 'heading': return `${'#'.repeat(node.attrs && node.attrs.level || 2)} ${children}\n\n`
+    case 'bulletList': return `${listItems(node, '-')}\n`
+    case 'orderedList': return `${listItems(node, '1.')}\n`
+    case 'listItem': return children
+    case 'codeBlock': return `\`\`\`${node.attrs && node.attrs.language || ''}\n${children}\n\`\`\`\n\n`
+    case 'blockquote': return children.split('\n').filter(Boolean).map((line) => `> ${line}`).join('\n') + '\n\n'
+    case 'rule': return '---\n\n'
+    case 'mention': return (node.attrs && (node.attrs.text || node.attrs.displayName)) || ''
+    case 'inlineCard': return (node.attrs && node.attrs.url) || ''
+    default: return children
+  }
+}
+
+function listItems(node, marker) {
+  return (node.content || []).map((item, index) => {
+    const prefix = marker === '1.' ? `${index + 1}.` : marker
+    return `${prefix} ${adfToMarkdown(item).trim().replace(/\n+/g, '\n  ')}`
+  }).join('\n')
+}
+
+function deriveAcceptance(description, heading = 'Criterios de aceptación') {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const match = String(description || '').match(new RegExp(`^##\\s+(?:\\d+[.)]\\s*)?${escaped}\\s*$`, 'im'))
+  if (!match) return ''
+  const rest = description.slice(match.index + match[0].length)
+  const next = rest.search(/^##\s+/m)
+  return (next < 0 ? rest : rest.slice(0, next)).trim()
+}
+
+function normalizeIssue(issue, config) {
+  const fields = issue.fields || {}
+  const description = typeof fields.description === 'string' ? fields.description : adfToMarkdown(fields.description)
+  const item = {
+    key: issue.key,
+    id: String(issue.id || ''),
+    url: `${config.baseUrl}/browse/${issue.key}`,
+    type: fields.issuetype && fields.issuetype.name || 'Issue',
+    summary: String(fields.summary || '').trim(),
+    description: description.trim(),
+    acceptance: deriveAcceptance(description, config.acceptanceHeading || 'Criterios de aceptación'),
+    status: fields.status && fields.status.name || '',
+    assignee: fields.assignee ? {
+      accountId: fields.assignee.accountId || '',
+      displayName: fields.assignee.displayName || '',
+    } : null,
+    parent: fields.parent ? fields.parent.key || '' : '',
+    components: (fields.components || []).map((value) => value.name).filter(Boolean),
+    labels: fields.labels || [],
+    updatedAt: fields.updated || '',
+  }
+  if (!JIRA_KEY.test(item.key)) throw new Error(`Clave Jira inválida: ${item.key}`)
+  if (!item.summary) throw new Error(`${item.key}: falta summary`)
+  return item
+}
+
+function normalizeFixture(payload, config) {
+  const issues = Array.isArray(payload) ? payload : payload.issues
+  if (!Array.isArray(issues)) throw new Error('Fixture Jira debe ser un array o { issues: [] }')
+  return issues.map((issue) => normalizeIssue(issue, config))
+}
+
+async function fetchItems(config, options = {}) {
+  const fetchImpl = options.fetchImpl || globalThis.fetch
+  const timeoutMs = options.timeoutMs || config.timeoutMs || 30_000
+  const maxPages = options.maxPages || config.maxPages || 100
+  const token = process.env[config.auth.tokenEnv]
+  const email = config.auth.emailEnv ? process.env[config.auth.emailEnv] : ''
+  if (!token) throw new Error(`Falta la variable ${config.auth.tokenEnv}`)
+  if (config.auth.type === 'basic' && !email) throw new Error(`Falta la variable ${config.auth.emailEnv}`)
+  const authorization = config.auth.type === 'basic'
+    ? `Basic ${Buffer.from(`${email}:${token}`).toString('base64')}`
+    : `Bearer ${token}`
+  const fields = [
+    'summary',
+    'description',
+    'issuetype',
+    'status',
+    'assignee',
+    'parent',
+    'components',
+    'labels',
+    'updated',
+  ]
+  const issues = []
+  const tokens = new Set()
+  let pages = 0
+  let nextPageToken
+  do {
+    if (++pages > maxPages) throw new Error(`Jira excedió el límite de ${maxPages} páginas`)
+    if (nextPageToken && tokens.has(nextPageToken)) {
+      throw new Error('Jira devolvió un nextPageToken repetido')
+    }
+    if (nextPageToken) tokens.add(nextPageToken)
+    const response = await fetchImpl(`${config.baseUrl}/rest/api/3/search/jql`, {
+      method: 'POST',
+      headers: { authorization, accept: 'application/json', 'content-type': 'application/json' },
+      body: JSON.stringify({ jql: config.jql, fields, maxResults: config.pageSize || 100, nextPageToken }),
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    if (!response.ok) throw new Error(`Jira respondió HTTP ${response.status}`)
+    const page = await response.json()
+    issues.push(...(page.issues || []))
+    nextPageToken = page.nextPageToken
+    if (page.isLast === true) nextPageToken = undefined
+  } while (nextPageToken)
+  return issues.map((issue) => normalizeIssue(issue, config))
+}
+
+module.exports = { adfToMarkdown, deriveAcceptance, fetchItems, normalizeFixture, normalizeIssue, validateConfig }

package/engine/integrations/registry.js

@@ -0,0 +1,390 @@
+'use strict'
+
+// Registro y ciclo común de proveedores externos.
+
+const fs = require('fs')
+const path = require('path')
+const F = require('../core/files')
+const S = require('./state')
+const P = require('./proposals')
+const W = require('./writeback')
+
+const STATES = S.STATES
+const sha256 = S.sha256
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')) } catch (error) {
+    throw new Error(`${file}: JSON inválido o ausente (${error.message})`)
+  }
+}
+
+function writeJson(file, value) {
+  F.atomicWriteJson(file, value)
+}
+
+function safeSegment(value, label) {
+  const segment = String(value || '')
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(segment) || segment === '.' || segment === '..') {
+    throw new Error(`${label} inválido: ${segment || '(vacío)'}`)
+  }
+  return segment
+}
+
+function providerConfig(root, name) {
+  safeSegment(name, 'Proveedor')
+  const registryFile = path.join(root, 'integrations', 'config.json')
+  const registry = readJson(registryFile)
+  const entry = (registry.providers || {})[name]
+  if (!entry) throw new Error(`Proveedor no registrado: ${name}`)
+  const configFile = path.resolve(path.dirname(registryFile), entry.config || `${name}/config.json`)
+  F.assertWithin(path.dirname(registryFile), configFile, `${name}: config`)
+  return { registry, entry, config: readJson(configFile), configFile }
+}
+
+function adapter(name) {
+  if (name === 'jira') return require('./providers/jira')
+  throw new Error(`No existe adaptador para ${name}`)
+}
+
+function sensitivePath(value, trail = '') {
+  if (!value || typeof value !== 'object') return ''
+  for (const [key, child] of Object.entries(value)) {
+    const next = trail ? `${trail}.${key}` : key
+    if (/(password|secret|token|authorization|cookie)$/i.test(key) && !/Env$/i.test(key)) return next
+    const nested = sensitivePath(child, next)
+    if (nested) return nested
+  }
+  return ''
+}
+
+const frontmatter = S.frontmatter
+const replaceField = S.replaceField
+const draftSections = S.sections
+const renderDraft = S.renderDraft
+const stagingItems = S.readStaging
+function validate(root, onlyProvider = '') {
+  const registryFile = path.join(root, 'integrations', 'config.json')
+  const errors = []
+  const warnings = []
+  let registry
+  try { registry = readJson(registryFile) } catch (error) { return { errors: [error.message], warnings } }
+  const providers = Object.entries(registry.providers || {}).filter(([name]) => !onlyProvider || name === onlyProvider)
+  let workspaces = []
+  try {
+    const ops = readJson(path.join(root, 'ops.config.json'))
+    workspaces = (ops.workspaceRoots || []).map((workspace) => ({
+      ...workspace,
+      resolved: path.resolve(root, workspace.path),
+    }))
+  } catch (error) {
+    errors.push(error.message)
+  }
+  if (!providers.length && onlyProvider) errors.push(`Proveedor no registrado: ${onlyProvider}`)
+  for (const [name, entry] of providers) {
+    if (!entry.adapter) errors.push(`${name}: falta adapter`)
+    let loaded
+    try { loaded = providerConfig(root, name) } catch (error) { errors.push(error.message); continue }
+    const secret = sensitivePath(loaded.config)
+    if (secret) errors.push(`${name}: ${secret} no puede contener secretos; usa una variable de entorno`)
+    try {
+      adapter(name).validateConfig(loaded.config, errors, warnings)
+    } catch (error) {
+      errors.push(`${name}: ${error.message}`)
+    }
+    const stagedKeys = new Map()
+    for (const staged of stagingItems(root, name)) {
+      const at = `integrations/${name}/staging/${staged.category}/${staged.key}`
+      if (stagedKeys.has(staged.key)) {
+        errors.push(`${at}: clave duplicada; también existe en ${stagedKeys.get(staged.key)}`)
+      } else {
+        stagedKeys.set(staged.key, at)
+      }
+      let snapshot
+      let draft
+      try {
+        snapshot = readJson(path.join(staged.dir, 'remote.json'))
+      } catch (error) {
+        errors.push(error.message)
+        continue
+      }
+      try { draft = fs.readFileSync(path.join(staged.dir, 'draft.md'), 'utf8') } catch (error) {
+        errors.push(`${at}: falta draft.md`); continue
+      }
+      const fields = frontmatter(draft)
+      if (snapshot.schemaVersion !== 2 || snapshot.provider !== name) {
+        errors.push(`${at}: schema/provider inválido`)
+      }
+      if (snapshot.item.key !== staged.key || fields.remote !== staged.key) {
+        errors.push(`${at}: identidad remota inconsistente`)
+      }
+      if (!STATES.includes(fields.state)) errors.push(`${at}: state inválido ${fields.state || '(vacío)'}`)
+      if (!['candidate', 'context'].includes(snapshot.sync.role)) {
+        errors.push(`${at}: sync.role inválido`)
+      }
+      if (!snapshot.sync.base || !snapshot.sync.baseAt) {
+        errors.push(`${at}: falta la base remota reconciliada`)
+      }
+      if (typeof snapshot.sync.missingFromRemote !== 'boolean') {
+        errors.push(`${at}: missingFromRemote debe ser boolean`)
+      }
+      const actualDraftChanged = sha256(draft) !== snapshot.sync.draftBaseHash
+      if (snapshot.sync.draftBaseHash && snapshot.sync.draftChanged !== actualDraftChanged) {
+        errors.push(`${at}: draftChanged no coincide con el contenido real`)
+      }
+      const signals = S.derive(snapshot, draft)
+      if (snapshot.sync.role === 'context' && fields.state !== 'context') {
+        errors.push(`${at}: context exige state=context`)
+      }
+      if (snapshot.sync.role === 'context' && signals.outgoing.length) {
+        errors.push(`${at}: un contexto no puede contener curación local`)
+      }
+      if (snapshot.sync.missingFromRemote && fields.state === 'ready') {
+        errors.push(`${at}: un item ausente del remoto no puede estar ready`)
+      }
+      if (fields.state === 'promoted' && signals.diverged) {
+        warnings.push(`${at}: el remoto cambió después de la promoción`)
+      }
+      if (fields.state === 'ready') {
+        const sections = draftSections(draft)
+        if (!fields.service) errors.push(`${at}: ready exige service`)
+        else if (!workspaces.some((workspace) => fs.existsSync(path.join(workspace.resolved, fields.service)))) {
+          errors.push(`${at}: service ${fields.service} no existe en las raíces configuradas`)
+        }
+        if (!['epic', 'story'].includes(fields.promotionKind)) {
+          errors.push(`${at}: ready exige promotionKind epic|story`)
+        }
+        if (fields.promotionKind === 'story' && (!/^\d{3}$/.test(fields.promotionEpic) || !fields.promotionCriteria)) {
+          errors.push(`${at}: story exige promotionEpic NNN y promotionCriteria`)
+        }
+        if (!sections.Aceptación || /^(por definir|n\/a|pendiente)\.?$/i.test(sections.Aceptación)) {
+          errors.push(`${at}: ready exige aceptación concreta`)
+        }
+        if (signals.incoming.length) {
+          errors.push(`${at}: ready tiene cambios remotos sin reconciliar`)
+        }
+        if (signals.conflict.length) {
+          errors.push(`${at}: ready tiene conflicto en ${signals.conflict.join(', ')}`)
+        }
+      }
+    }
+    errors.push(...P.validate(root, name, workspaces))
+  }
+  return { errors, warnings }
+}
+
+async function sync(root, name, options = {}) {
+  const { entry, config } = providerConfig(root, name)
+  if (!entry.enabled || !config.enabled) throw new Error(`${name} está deshabilitado`)
+  const provider = adapter(name)
+  const items = options.fixture
+    ? provider.normalizeFixture(readJson(path.resolve(options.fixture)), config)
+    : await provider.fetchItems(config)
+  const staging = path.join(root, 'integrations', name, 'staging')
+  fs.mkdirSync(staging, { recursive: true })
+  const existing = new Map(stagingItems(root, name).map((item) => [item.key, item]))
+  const seen = new Set()
+  const result = { created: 0, refreshed: 0, preserved: 0, removed: 0, missing: 0 }
+  for (const item of items) {
+    const itemKey = safeSegment(item.key, `${name}: item.key`)
+    if (seen.has(itemKey)) throw new Error(`${name}: item duplicado ${itemKey}`)
+    const category = S.categoryOf(item)
+    const desiredDir = path.join(staging, category, itemKey)
+    const found = existing.get(itemKey)
+    if (found && found.dir !== desiredDir) {
+      fs.mkdirSync(path.dirname(desiredDir), { recursive: true })
+      fs.renameSync(found.dir, desiredDir)
+    }
+    seen.add(itemKey)
+    const snapshotFile = path.join(desiredDir, 'remote.json')
+    const draftFile = path.join(desiredDir, 'draft.md')
+    const previous = fs.existsSync(snapshotFile) ? readJson(snapshotFile) : null
+    const previousDraft = fs.existsSync(draftFile) ? fs.readFileSync(draftFile, 'utf8') : ''
+    const role = S.roleOf(item, config)
+    const state = role === 'context' ? 'context' : 'pending'
+    let draft
+    let base
+    let baseAt
+    if (!previous) {
+      draft = renderDraft(item, config, state)
+      base = S.remoteView(item)
+      baseAt = new Date().toISOString()
+      result.created++
+    } else {
+      const signals = S.derive({ ...previous, item }, previousDraft)
+      const locallyChanged = sha256(previousDraft) !== previous.sync.draftBaseHash
+      const regenerate = role === 'context' || !locallyChanged
+      if (regenerate) {
+        draft = renderDraft(item, config, state)
+        base = S.remoteView(item)
+        baseAt = new Date().toISOString()
+        result.refreshed++
+      } else {
+        draft = previousDraft
+        if (signals.incoming.length && frontmatter(draft).state === 'ready') {
+          draft = replaceField(draft, 'state', 'pending')
+        }
+        base = previous.sync.base || S.remoteView(previous.item)
+        baseAt = previous.sync.baseAt || previous.sync.pulledAt
+        result.preserved++
+      }
+    }
+    const canonical = renderDraft(item, config, state)
+    const snapshot = {
+      schemaVersion: 2,
+      provider: name,
+      item,
+      sync: {
+        role,
+        pulledAt: new Date().toISOString(),
+        missingFromRemote: false,
+        base,
+        baseAt,
+        draftBaseHash: sha256(canonical),
+        draftChanged: sha256(draft) !== sha256(canonical),
+        config: { serviceFrom: config.serviceFrom },
+      },
+    }
+    fs.mkdirSync(desiredDir, { recursive: true })
+    F.atomicWrite(draftFile, draft)
+    writeJson(snapshotFile, snapshot)
+  }
+  const complete = options.complete !== false
+  if (complete) cleanupMissing(root, name, seen, result)
+  writeJson(path.join(staging, 'sync-state.json'), {
+    schemaVersion: 2,
+    provider: name,
+    complete,
+    pulledAt: new Date().toISOString(),
+    keys: [...seen].sort(),
+  })
+  return { ...result, total: items.length }
+}
+
+function cleanupMissing(root, name, seen, result) {
+  for (const staged of stagingItems(root, name)) {
+    if (seen.has(staged.key)) continue
+    const snapshotFile = path.join(staged.dir, 'remote.json')
+    const draftFile = path.join(staged.dir, 'draft.md')
+    const snapshot = readJson(snapshotFile)
+    const draft = fs.readFileSync(draftFile, 'utf8')
+    const state = frontmatter(draft).state
+    const curated = sha256(draft) !== snapshot.sync.draftBaseHash
+    if (!curated && !['promoted', 'ready'].includes(state)) {
+      F.assertWithin(path.join(root, 'integrations', name, 'staging'), staged.dir)
+      fs.rmSync(staged.dir, { recursive: true })
+      result.removed++
+      continue
+    }
+    snapshot.sync.missingFromRemote = true
+    writeJson(snapshotFile, snapshot)
+    result.missing++
+  }
+}
+
+function promote(root, name, key) {
+  safeSegment(name, 'Proveedor')
+  safeSegment(key, `${name}: clave remota`)
+  const validation = validate(root, name)
+  if (validation.errors.length) {
+    throw new Error(`La integración no está lista:\n- ${validation.errors.join('\n- ')}`)
+  }
+  const matches = stagingItems(root, name).filter((item) => item.key === key)
+  if (matches.length !== 1) throw new Error(`${key}: no se resolvió un item único en staging`)
+  const dir = matches[0].dir
+  const snapshot = readJson(path.join(dir, 'remote.json'))
+  const draftFile = path.join(dir, 'draft.md')
+  let draft = fs.readFileSync(draftFile, 'utf8')
+  const fields = frontmatter(draft)
+  if (fields.state !== 'ready') throw new Error(`${key}: state debe ser ready`)
+  const sections = draftSections(draft)
+  const planning = path.join(root, 'planning')
+  const roadmap = path.join(planning, 'roadmap')
+  if (fields.promotionKind === 'epic') {
+    const roadmapFiles = fs.readdirSync(roadmap).filter((file) => /^epic-\d{3}-/.test(file))
+    const recovered = roadmapFiles.find((file) => {
+      const content = fs.readFileSync(path.join(roadmap, file), 'utf8')
+      return content.includes(`source: ${name}`) && content.includes(`remote: ${key}`)
+    })
+    const existing = roadmapFiles
+      .map((file) => (file.match(/^epic-(\d{3})-/) || [])[1])
+      .filter(Boolean)
+    const next = String(Math.max(0, ...existing.map(Number)) + 1).padStart(3, '0')
+    const recoveredNum = recovered && (recovered.match(/^epic-(\d{3})-/) || [])[1]
+    const num = recoveredNum || fields.promotionEpic || next
+    const slug = slugify(sections.title)
+    const target = path.join(roadmap, recovered || `epic-${num}-${slug}.md`)
+    const content = `---\nepic: ${num}\ntitle: ${sections.title}\nstatus: open\n` +
+      `service: ${fields.service}\nsource: ${name}\nremote: ${key}\n---\n\n` +
+      `# Épica ${num} — ${sections.title}\n\n## Resultado\n\n${sections.Descripción}\n\n` +
+      `## Criterios\n\n- **C1** — ${oneLine(sections.Aceptación)}\n\n` +
+      `## Contexto relevante\n\n- Importado desde ${name}:${key}; validar rutas del servicio antes de activar.\n\n` +
+      `## Historias\n\n- [ ] **${slug}** (→ C1) — ${oneLine(sections.title)}. ` +
+      `(service: ${fields.service})\n`
+    if (fs.existsSync(target)) {
+      const existingContent = fs.readFileSync(target, 'utf8')
+      if (!existingContent.includes(`remote: ${key}`) || !existingContent.includes(`source: ${name}`)) {
+        throw new Error(`Ya existe ${target}`)
+      }
+    } else {
+      F.atomicWrite(target, content)
+    }
+  } else {
+    const files = fs.readdirSync(roadmap).filter((file) => file.startsWith(`epic-${fields.promotionEpic}-`))
+    if (files.length !== 1) throw new Error(`${key}: no se resolvió epic-${fields.promotionEpic}`)
+    const target = path.join(roadmap, files[0])
+    let spec = fs.readFileSync(target, 'utf8')
+    if (!new RegExp(`\\*\\*${fields.promotionCriteria}\\*\\*`).test(spec)) {
+      throw new Error(`${key}: no existe ${fields.promotionCriteria}`)
+    }
+    const slug = `${name}-${key.toLowerCase()}-${slugify(sections.title)}`
+    const line = `- [ ] **${slug}** (→ ${fields.promotionCriteria}) — ` +
+      `${oneLine(sections.title)}. _Aceptación: ${oneLine(sections.Aceptación)}_ ` +
+      `(service: ${fields.service}) (remote: ${name}:${key})`
+    if (!spec.includes(`**${slug}**`)) {
+      const stories = spec.match(/^## Historias\s*$/m)
+      if (!stories) throw new Error(`${key}: epic-${fields.promotionEpic} no tiene sección Historias`)
+      const afterHeading = stories.index + stories[0].length
+      const nextHeadingOffset = spec.slice(afterHeading).search(/^##\s+/m)
+      const insertAt = nextHeadingOffset < 0 ? spec.length : afterHeading + nextHeadingOffset
+      const before = spec.slice(0, insertAt).trimEnd()
+      const after = spec.slice(insertAt).replace(/^\s+/, '')
+      spec = `${before}\n\n${line}\n\n${after}`.trimEnd() + '\n'
+      F.atomicWrite(target, spec)
+    }
+  }
+  draft = replaceField(draft, 'state', 'promoted')
+  draft = replaceField(draft, 'promotedAt', `"${new Date().toISOString()}"`)
+  F.atomicWrite(draftFile, draft)
+  snapshot.sync.draftChanged = true
+  writeJson(path.join(dir, 'remote.json'), snapshot)
+  return { key, kind: fields.promotionKind }
+}
+
+function reconcile(root, name, operation, keys) {
+  providerConfig(root, name)
+  return S.reconcile(root, name, operation, keys)
+}
+
+function writebackPlan(root, name) {
+  const { config } = providerConfig(root, name)
+  return W.summarize(W.plan(root, name, config))
+}
+
+const slugify = (value) => String(value).normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase()
+  .replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 70)
+const oneLine = (value) => String(value).replace(/\s+/g, ' ').trim()
+
+module.exports = {
+  STATES,
+  adapter,
+  draftSections,
+  frontmatter,
+  promote,
+  providerConfig,
+  reconcile,
+  safeSegment,
+  stagingItems,
+  sync,
+  validate,
+  writebackPlan,
+}