hivecode-mcp 0.12.2 → 0.13.0

package/hive-webhook.js

@@ -0,0 +1,54 @@
+// hive-webhook -- one Slack or Discord incoming-webhook URL, and the rule for what may be sent to it.
+//
+// Shared by the GitHub watcher (hive-github.js) and the room notifier (hive-notify.js): the same
+// URL works for both, and the same two promises hold for both.
+//   1. Nothing with a key or token in it leaves: every message is scrubbed first.
+//   2. A notification that fails is logged and dropped, never retried in a loop and never a reason
+//      to stop: it is a courtesy, the work is the point.
+import { findSecrets } from './hive-secrets.js'
+
+/** Every key or token in `text` replaced. Run on everything that goes to GitHub or a webhook. */
+export function scrub(text) {
+  let s = String(text || '')
+  for (const f of findSecrets(s, { tokens: true })) s = s.split(f.value).join(`[${f.kind} removed]`)
+  return s
+}
+
+export function cleanError(e, url) {
+  let s = String(e && (e.message || e) || 'unknown error')
+  if (url) s = s.split(url).join('[webhook url removed]')
+  try {
+    const u = new URL(url)
+    if (u.pathname && u.pathname !== '/') s = s.split(u.pathname).join('[path removed]')
+  } catch { }
+  s = scrub(s)
+  s = s.replace(/Failed to parse URL from .+/i, 'Failed to parse URL')
+  return s
+}
+
+/** `send(text)` resolves true when the webhook took it. Slack wants {text}, Discord {content}; any
+ *  other host gets Slack format ({text}). */
+export function makeNotifier(url, { fetchImpl = globalThis.fetch, log = () => {} } = {}) {
+  if (!url) return async () => false
+  let host = ''
+  try { host = new URL(url).hostname.toLowerCase() } catch { host = '' }
+  const slack = /(^|\.)slack\.com$/.test(host)
+  const discord = /(^|\.)discord(app)?\.com$/.test(host)
+  const kind = discord ? 'discord' : slack ? 'slack' : 'other'
+  const send = async (text) => {
+    const msg = scrub(text)
+    // allowed_mentions: an issue titled "@everyone" must not page a whole Discord server.
+    const body = discord ? { content: msg.slice(0, 1900), allowed_mentions: { parse: [] } } : { text: msg }
+    try {
+      const r = await fetchImpl(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(10000) })
+      if (!r.ok) { log(`notification not delivered: HTTP ${r.status}`); return false }
+      return true
+    } catch (e) {
+      log(`notification not delivered: ${cleanError(e, url)}`)
+      return false
+    }
+  }
+  send.host = host
+  send.kind = kind
+  return send
+}

package/icr-merge.js

@@ -1,58 +1,58 @@
-// icr-merge.js — the bridge that brings ICR into the live product, SAFELY.
-//
-// Hivecode's reconcile() merges concurrent edits with merge3() (a line-level 3-way
-// merge). merge3 is convergent: across many peers it always settles on one canonical
-// text. ICR's structural merge produces a DIFFERENT canonical form (it may reorder or
-// reformat). Mixing two merge algorithms in a live multi-peer sync means the same logical
-// content has two byte-forms, and peers ping-pong between them — which corrupts files
-// (duplicated/*dropped* lines). So we do NOT change merge bytes with ICR here.
-//
-// Instead ICR runs in ADVISORY mode: merge3 still produces the bytes (full convergence
-// preserved, identical to pre-ICR behavior), and ICR runs alongside purely to DETECT the
-// meaning-level problems a line merge can't see — a dangling reference, a rename, a
-// same-declaration clash — and surface them as a warning on the activity feed. This ships
-// ICR's core value (catching semantic breaks) with zero divergence risk.
-//
-// ICR's full structural/rename AUTO-MERGE lives in the library (icr.js) and is proven by
-// the test suite + fuzzer; turning it on in the product is a later step that needs a
-// format-preserving, single-canonical-form merge so peers can't diverge.
-
-import { structuralMerge, supports } from './icr.js'
-import { merge3 } from './core.js'
-
-// Turn ICR's machine conflict keys into a human sentence for the activity feed / chat.
-function describeConflicts(conflicts) {
-  return (conflicts || []).map((c) => {
-    if (c.startsWith('ref:')) return `'${c.slice(4)}' was removed or renamed but is still used`
-    if (c.startsWith('fn:')) return `both sides changed function ${c.slice(3)}`
-    if (c.startsWith('class:')) return `both sides changed class ${c.slice(6)}`
-    if (c.startsWith('var:')) return `both sides changed ${c.slice(4)}`
-    return `both sides changed ${c}`
-  }).join('; ')
-}
-
-// Same shape as merge3 — { text, conflict } — plus an `icr` tag ('structural'|'rename')
-// and an optional `icrWarning`. ICR's format-preserving merge is convergent (symmetric +
-// fixed-point, verified by icr-converge-test.js), so its 'auto' result is used as the
-// merged bytes for supported files; merge3 covers conflicts, fallbacks, and other languages.
-export function icrMerge3(base, mine, theirs, relPath) {
-  const lm = merge3(base, mine, theirs)
-  if (!supports(relPath)) return lm
-
-  let r
-  try { r = structuralMerge(base, mine, theirs, { filename: relPath }) }
-  catch { return lm } // ICR must never break a sync
-
-  if (r.status === 'auto') {
-    const renamed = r.renames && r.renames.length
-    return {
-      text: r.text, conflict: false, icr: renamed ? 'rename' : 'structural',
-      icrWarning: renamed ? `auto-applied rename ${r.renames.join(', ')} — call sites updated` : undefined,
-    }
-  }
-  // A meaning-level conflict the line merge can't represent (dangling ref / clash): keep
-  // the safe line-merge bytes, but surface what ICR caught so it isn't shipped silently.
-  if (r.status === 'semantic-conflict')
-    return { ...lm, icrWarning: describeConflicts(r.conflicts) }
-  return lm // 'fallback'
-}
+// icr-merge.js — the bridge that brings ICR into the live product, SAFELY.
+//
+// Hivecode's reconcile() merges concurrent edits with merge3() (a line-level 3-way
+// merge). merge3 is convergent: across many peers it always settles on one canonical
+// text. ICR's structural merge produces a DIFFERENT canonical form (it may reorder or
+// reformat). Mixing two merge algorithms in a live multi-peer sync means the same logical
+// content has two byte-forms, and peers ping-pong between them — which corrupts files
+// (duplicated/*dropped* lines). So we do NOT change merge bytes with ICR here.
+//
+// Instead ICR runs in ADVISORY mode: merge3 still produces the bytes (full convergence
+// preserved, identical to pre-ICR behavior), and ICR runs alongside purely to DETECT the
+// meaning-level problems a line merge can't see — a dangling reference, a rename, a
+// same-declaration clash — and surface them as a warning on the activity feed. This ships
+// ICR's core value (catching semantic breaks) with zero divergence risk.
+//
+// ICR's full structural/rename AUTO-MERGE lives in the library (icr.js) and is proven by
+// the test suite + fuzzer; turning it on in the product is a later step that needs a
+// format-preserving, single-canonical-form merge so peers can't diverge.
+
+import { structuralMerge, supports } from './icr.js'
+import { merge3 } from './core.js'
+
+// Turn ICR's machine conflict keys into a human sentence for the activity feed / chat.
+function describeConflicts(conflicts) {
+  return (conflicts || []).map((c) => {
+    if (c.startsWith('ref:')) return `'${c.slice(4)}' was removed or renamed but is still used`
+    if (c.startsWith('fn:')) return `both sides changed function ${c.slice(3)}`
+    if (c.startsWith('class:')) return `both sides changed class ${c.slice(6)}`
+    if (c.startsWith('var:')) return `both sides changed ${c.slice(4)}`
+    return `both sides changed ${c}`
+  }).join('; ')
+}
+
+// Same shape as merge3 — { text, conflict } — plus an `icr` tag ('structural'|'rename')
+// and an optional `icrWarning`. ICR's format-preserving merge is convergent (symmetric +
+// fixed-point, verified by icr-converge-test.js), so its 'auto' result is used as the
+// merged bytes for supported files; merge3 covers conflicts, fallbacks, and other languages.
+export function icrMerge3(base, mine, theirs, relPath) {
+  const lm = merge3(base, mine, theirs)
+  if (!supports(relPath)) return lm
+
+  let r
+  try { r = structuralMerge(base, mine, theirs, { filename: relPath }) }
+  catch { return lm } // ICR must never break a sync
+
+  if (r.status === 'auto') {
+    const renamed = r.renames && r.renames.length
+    return {
+      text: r.text, conflict: false, icr: renamed ? 'rename' : 'structural',
+      icrWarning: renamed ? `auto-applied rename ${r.renames.join(', ')} — call sites updated` : undefined,
+    }
+  }
+  // A meaning-level conflict the line merge can't represent (dangling ref / clash): keep
+  // the safe line-merge bytes, but surface what ICR caught so it isn't shipped silently.
+  if (r.status === 'semantic-conflict')
+    return { ...lm, icrWarning: describeConflicts(r.conflicts) }
+  return lm // 'fallback'
+}