hivecode-mcp 0.12.2 → 0.12.4

package/lang-json.js

@@ -1,211 +1,211 @@
-// JSON language provider for ICR — the one provider where the guarantee is PERFECT,
-// because JSON.parse IS the real parser (no heuristics anywhere).
-//
-// JSON is the most-merged file type in a repository (package.json, tsconfig, lockfile
-// fragments, CI configs), and the classic line-merge failure is two sides editing
-// nearby keys — git conflicts or, worse, fuses into invalid JSON. ICR merges JSON as
-// DATA: value-wise 3-way merge, keyed by object path, so:
-//   • different keys edited on each side        -> clean merge, both kept
-//   • the SAME path changed differently         -> semantic conflict naming the path
-//     (surfaced as a machine-resolvable unit, so an agent judge can reconcile it)
-//   • one side deletes a key the other changed  -> conflict (delete vs change)
-//   • arrays: one-sided changes merge; both-sided changes merge when the edited
-//     regions are DISJOINT (prefix/suffix diff — appends, prepends, middle inserts);
-//     overlapping array edits are an honest conflict
-// Output is serialized with the file's own indentation style (detected from the base)
-// and preserves the trailing-newline convention, so diffs stay minimal.
-
-const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)
-const eq = (x, y) => JSON.stringify(x) === JSON.stringify(y)
-
-// PRECISION SAFETY GATE. The data merge re-serializes the whole document, which means
-// every number goes through JS float64 — and that CORRUPTS values nobody touched:
-// 9007199254740993 (beyond 2^53) silently loses a digit; 1e999 becomes Infinity and
-// then `null`. Shipping a "clean" merge that corrupts untouched data is the cardinal
-// sin, so: scan every number literal (string-aware); if ANY cannot survive the
-// round-trip value-identically, refuse the data merge entirely — the engine falls back
-// to the safe line tier, which never rewrites untouched bytes. (Found by the
-// adversarial crucible, not by users — the way it should be.)
-function numbersSafe(src) {
-  const n = src.length
-  let i = 0
-  while (i < n) {
-    const c = src[i]
-    if (c === '"') { i++; while (i < n) { if (src[i] === '\\') { i += 2; continue } if (src[i] === '"') { i++; break } i++ } continue }
-    if (c === '-' || (c >= '0' && c <= '9')) {
-      let j = i + 1
-      while (j < n && /[0-9eE+.-]/.test(src[j])) j++
-      const tok = src.slice(i, j)
-      const v = Number(tok)
-      if (!Number.isFinite(v)) return false                                  // 1e999 → Infinity → null
-      if (Number.isInteger(v) && Math.abs(v) > Number.MAX_SAFE_INTEGER) return false // beyond 2^53
-      const digits = tok.replace(/[^0-9]/g, '').replace(/^0+/, '')
-      if (digits.length > 15 && !eq(Number(tok), Number(v.toPrecision(15)))) return false // >15 sig digits at risk
-      i = j; continue
-    }
-    i++
-  }
-  return true
-}
-
-// Detect the base file's indent unit ('  ', '    ', '\t', …). Defaults to two spaces.
-function detectIndent(src) {
-  const m = /\n([ \t]+)\S/.exec(src)
-  return m ? m[1] : '  '
-}
-
-// 3-way merge of two ARRAYS against base, by disjoint-region splice (the same
-// prefix/suffix discipline the engine's token merge uses, on JSON-equal elements).
-// Returns the merged array, or null for an overlapping (real) conflict.
-function mergeArray(base, a, b) {
-  const K = (arr) => arr.map((x) => JSON.stringify(x))
-  const diffRange = (B, O) => {
-    if (B.length === O.length && B.every((x, i) => x === O[i])) return null
-    let p = 0
-    const maxp = Math.min(B.length, O.length)
-    while (p < maxp && B[p] === O[p]) p++
-    let s = 0
-    while (s < B.length - p && s < O.length - p && B[B.length - 1 - s] === O[O.length - 1 - s]) s++
-    return { bStart: p, bEnd: B.length - s, oStart: p, oEnd: O.length - s }
-  }
-  const KB = K(base), ra = diffRange(KB, K(a)), rb = diffRange(KB, K(b))
-  if (!ra) return b
-  if (!rb) return a
-  if (ra.bStart < rb.bEnd && rb.bStart < ra.bEnd) return null // overlapping regions
-  if (ra.bStart === rb.bStart) return null                    // ambiguous same-point edits
-  const edits = [
-    { s: ra.bStart, e: ra.bEnd, ins: a.slice(ra.oStart, ra.oEnd) },
-    { s: rb.bStart, e: rb.bEnd, ins: b.slice(rb.oStart, rb.oEnd) },
-  ].sort((x, y) => y.s - x.s)
-  let out = base.slice()
-  for (const ed of edits) out.splice(ed.s, ed.e - ed.s, ...ed.ins)
-  return out
-}
-
-// SYMMETRY. The merged object is re-serialized with JSON.stringify, which emits keys in
-// INSERTION order — so the order we walk the key union IS the output byte order. The
-// obvious union, `[...keys(base), ...keys(a), ...keys(b)]`, is side-ordered: ours's new
-// keys always precede theirs's, so merge(base,a,b) and merge(base,b,a) produce clean
-// 'auto' results that differ byte-for-byte. Measured at 43/167 auto merges (26%) by
-// test/icr-data-torture-test.js. Semantically identical, but P2 SYMMETRY is asserted
-// byte-wise for every other language (icr-torture-test.js), and byte-inequality is
-// precisely what a CRDT peer and a git blob hash react to — the two consumers the README
-// names. So the union order must not depend on which side is called `a`:
-//   • keys present in base keep BASE's order (unchanged behaviour, minimal diffs);
-//   • keys added by either side follow, ordered by where their own author put them
-//     (min index across the sides that have it), ties broken by key name.
-// Both rules are symmetric in a/b, so swapping the sides cannot change the output.
-function unionKeys(base, a, b) {
-  const rank = new Map()
-  for (const obj of [a, b]) {
-    const ks = Object.keys(obj)
-    for (let i = 0; i < ks.length; i++) {
-      const k = ks[i]
-      if (k in base) continue
-      const prev = rank.get(k)
-      if (prev === undefined || i < prev) rank.set(k, i)
-    }
-  }
-  const added = [...rank.keys()].sort((x, y) => (rank.get(x) - rank.get(y)) || (x < y ? -1 : x > y ? 1 : 0))
-  return [...Object.keys(base), ...added]
-}
-
-// Value-wise 3-way merge. Fills `conflicts` (path strings) and `resolvable`
-// ({key, base, ours, theirs} with pretty-printed values) on same-path clashes;
-// the merged value keeps BASE at conflicted paths (the engine refuses the whole
-// merge when conflicts exist, so nothing partial ever ships).
-function mergeVal(base, a, b, path, conflicts, resolvable) {
-  if (eq(a, b)) return a
-  if (eq(a, base)) return b
-  if (eq(b, base)) return a
-  if (isObj(base) && isObj(a) && isObj(b)) {
-    const out = {}
-    for (const k of unionKeys(base, a, b)) {
-      const p = path ? path + '.' + k : k
-      const inB = k in base, inA = k in a, inBb = k in b
-      if (inB && !inA && !inBb) continue                                     // deleted on both sides
-      if (inB && !inA) {                                                     // ours deleted it
-        if (eq(b[k], base[k])) continue                                      // theirs untouched -> deletion wins
-        conflicts.push(p); resolvable.push(resUnit(p, base[k], undefined, b[k])); continue
-      }
-      if (inB && !inBb) {                                                    // theirs deleted it
-        if (eq(a[k], base[k])) continue
-        conflicts.push(p); resolvable.push(resUnit(p, base[k], a[k], undefined)); continue
-      }
-      if (!inB && inA && inBb) {                                             // both added
-        if (eq(a[k], b[k])) { out[k] = a[k]; continue }
-        if (isObj(a[k]) && isObj(b[k])) { out[k] = mergeVal({}, a[k], b[k], p, conflicts, resolvable); continue }
-        conflicts.push(p); resolvable.push(resUnit(p, undefined, a[k], b[k])); continue
-      }
-      if (!inB) { out[k] = inA ? a[k] : b[k]; continue }                     // one side added
-      out[k] = mergeVal(base[k], a[k], b[k], p, conflicts, resolvable)       // present everywhere
-    }
-    return out
-  }
-  if (Array.isArray(base) && Array.isArray(a) && Array.isArray(b)) {
-    const m = mergeArray(base, a, b)
-    if (m) return m
-    conflicts.push(path || '(root)'); resolvable.push(resUnit(path || '(root)', base, a, b))
-    return base
-  }
-  conflicts.push(path || '(root)')                                            // scalar/shape clash
-  resolvable.push(resUnit(path || '(root)', base, a, b))
-  return base
-}
-
-const show = (v) => (v === undefined ? '(deleted)' : JSON.stringify(v, null, 2))
-const resUnit = (p, base, ours, theirs) => ({ key: 'json:' + p, base: show(base), ours: show(ours), theirs: show(theirs) })
-
-export const json = {
-  id: 'json',
-  exts: ['.json'],
-  parses: (src) => { try { JSON.parse(String(src == null ? '' : src)); return true } catch { return false } },
-  // The engine's whole-document tier: merge the file as parsed data.
-  mergeWhole: (base, a, b) => {
-    if (!numbersSafe(base) || !numbersSafe(a) || !numbersSafe(b)) return null // precision hazard → safe fallback, never corrupt
-    let B, A, Bb
-    try { B = JSON.parse(base); A = JSON.parse(a); Bb = JSON.parse(b) } catch { return null }
-    const conflicts = [], resolvable = []
-    const merged = mergeVal(B, A, Bb, '', conflicts, resolvable)
-    if (conflicts.length) return { conflicts, resolvable }
-    const nl = /\n$/.test(base) || /\n$/.test(a) ? '\n' : ''
-    return { text: JSON.stringify(merged, null, detectIndent(base)) + nl }
-  },
-  // Minimal unit view (whole document) so generic engine paths stay well-defined;
-  // real merging happens in mergeWhole above.
-  units: (src) => [{ key: 'doc', text: String(src), start: 0, end: String(src).length }],
-  declaredNames: () => new Set(),
-  // INTENT RESOLUTION for data: a conflicted unit's "text" is a rendering of a parsed
-  // VALUE, so a judge's reconciliation is applied by setting the value at the unit's
-  // path (key 'json:<path>'), not by string replacement. The reconciled string must
-  // itself be valid JSON ('(deleted)' removes the key). Returns the re-serialized
-  // document, or null when it can't apply — resolveMerge then falls back to the safe
-  // conflict, so a malformed judgment never ships.
-  applyResolution: (text, unit, reconciled) => {
-    if (!unit || typeof unit.key !== 'string' || !unit.key.startsWith('json:')) return null
-    if (!numbersSafe(text)) return null // same precision gate: never re-serialize a doc we'd corrupt
-    let doc, value
-    try { doc = JSON.parse(text) } catch { return null }
-    const del = String(reconciled).trim() === '(deleted)'
-    if (!del) { try { value = JSON.parse(reconciled) } catch { return null } }
-    const path = unit.key.slice(5)
-    if (path === '(root)' || path === '') {
-      if (del) return null
-      doc = value
-    } else {
-      const parts = path.split('.')
-      let cur = doc
-      for (let i = 0; i < parts.length - 1; i++) {
-        if (cur == null || typeof cur !== 'object') return null
-        if (!(parts[i] in cur)) cur[parts[i]] = {}
-        cur = cur[parts[i]]
-      }
-      if (cur == null || typeof cur !== 'object') return null
-      const leaf = parts[parts.length - 1]
-      if (del) delete cur[leaf]
-      else cur[leaf] = value
-    }
-    const nl = /\n$/.test(text) ? '\n' : ''
-    return JSON.stringify(doc, null, detectIndent(text)) + nl
-  },
-}
+// JSON language provider for ICR — the one provider where the guarantee is PERFECT,
+// because JSON.parse IS the real parser (no heuristics anywhere).
+//
+// JSON is the most-merged file type in a repository (package.json, tsconfig, lockfile
+// fragments, CI configs), and the classic line-merge failure is two sides editing
+// nearby keys — git conflicts or, worse, fuses into invalid JSON. ICR merges JSON as
+// DATA: value-wise 3-way merge, keyed by object path, so:
+//   • different keys edited on each side        -> clean merge, both kept
+//   • the SAME path changed differently         -> semantic conflict naming the path
+//     (surfaced as a machine-resolvable unit, so an agent judge can reconcile it)
+//   • one side deletes a key the other changed  -> conflict (delete vs change)
+//   • arrays: one-sided changes merge; both-sided changes merge when the edited
+//     regions are DISJOINT (prefix/suffix diff — appends, prepends, middle inserts);
+//     overlapping array edits are an honest conflict
+// Output is serialized with the file's own indentation style (detected from the base)
+// and preserves the trailing-newline convention, so diffs stay minimal.
+
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)
+const eq = (x, y) => JSON.stringify(x) === JSON.stringify(y)
+
+// PRECISION SAFETY GATE. The data merge re-serializes the whole document, which means
+// every number goes through JS float64 — and that CORRUPTS values nobody touched:
+// 9007199254740993 (beyond 2^53) silently loses a digit; 1e999 becomes Infinity and
+// then `null`. Shipping a "clean" merge that corrupts untouched data is the cardinal
+// sin, so: scan every number literal (string-aware); if ANY cannot survive the
+// round-trip value-identically, refuse the data merge entirely — the engine falls back
+// to the safe line tier, which never rewrites untouched bytes. (Found by the
+// adversarial crucible, not by users — the way it should be.)
+function numbersSafe(src) {
+  const n = src.length
+  let i = 0
+  while (i < n) {
+    const c = src[i]
+    if (c === '"') { i++; while (i < n) { if (src[i] === '\\') { i += 2; continue } if (src[i] === '"') { i++; break } i++ } continue }
+    if (c === '-' || (c >= '0' && c <= '9')) {
+      let j = i + 1
+      while (j < n && /[0-9eE+.-]/.test(src[j])) j++
+      const tok = src.slice(i, j)
+      const v = Number(tok)
+      if (!Number.isFinite(v)) return false                                  // 1e999 → Infinity → null
+      if (Number.isInteger(v) && Math.abs(v) > Number.MAX_SAFE_INTEGER) return false // beyond 2^53
+      const digits = tok.replace(/[^0-9]/g, '').replace(/^0+/, '')
+      if (digits.length > 15 && !eq(Number(tok), Number(v.toPrecision(15)))) return false // >15 sig digits at risk
+      i = j; continue
+    }
+    i++
+  }
+  return true
+}
+
+// Detect the base file's indent unit ('  ', '    ', '\t', …). Defaults to two spaces.
+function detectIndent(src) {
+  const m = /\n([ \t]+)\S/.exec(src)
+  return m ? m[1] : '  '
+}
+
+// 3-way merge of two ARRAYS against base, by disjoint-region splice (the same
+// prefix/suffix discipline the engine's token merge uses, on JSON-equal elements).
+// Returns the merged array, or null for an overlapping (real) conflict.
+function mergeArray(base, a, b) {
+  const K = (arr) => arr.map((x) => JSON.stringify(x))
+  const diffRange = (B, O) => {
+    if (B.length === O.length && B.every((x, i) => x === O[i])) return null
+    let p = 0
+    const maxp = Math.min(B.length, O.length)
+    while (p < maxp && B[p] === O[p]) p++
+    let s = 0
+    while (s < B.length - p && s < O.length - p && B[B.length - 1 - s] === O[O.length - 1 - s]) s++
+    return { bStart: p, bEnd: B.length - s, oStart: p, oEnd: O.length - s }
+  }
+  const KB = K(base), ra = diffRange(KB, K(a)), rb = diffRange(KB, K(b))
+  if (!ra) return b
+  if (!rb) return a
+  if (ra.bStart < rb.bEnd && rb.bStart < ra.bEnd) return null // overlapping regions
+  if (ra.bStart === rb.bStart) return null                    // ambiguous same-point edits
+  const edits = [
+    { s: ra.bStart, e: ra.bEnd, ins: a.slice(ra.oStart, ra.oEnd) },
+    { s: rb.bStart, e: rb.bEnd, ins: b.slice(rb.oStart, rb.oEnd) },
+  ].sort((x, y) => y.s - x.s)
+  let out = base.slice()
+  for (const ed of edits) out.splice(ed.s, ed.e - ed.s, ...ed.ins)
+  return out
+}
+
+// SYMMETRY. The merged object is re-serialized with JSON.stringify, which emits keys in
+// INSERTION order — so the order we walk the key union IS the output byte order. The
+// obvious union, `[...keys(base), ...keys(a), ...keys(b)]`, is side-ordered: ours's new
+// keys always precede theirs's, so merge(base,a,b) and merge(base,b,a) produce clean
+// 'auto' results that differ byte-for-byte. Measured at 43/167 auto merges (26%) by
+// test/icr-data-torture-test.js. Semantically identical, but P2 SYMMETRY is asserted
+// byte-wise for every other language (icr-torture-test.js), and byte-inequality is
+// precisely what a CRDT peer and a git blob hash react to — the two consumers the README
+// names. So the union order must not depend on which side is called `a`:
+//   • keys present in base keep BASE's order (unchanged behaviour, minimal diffs);
+//   • keys added by either side follow, ordered by where their own author put them
+//     (min index across the sides that have it), ties broken by key name.
+// Both rules are symmetric in a/b, so swapping the sides cannot change the output.
+function unionKeys(base, a, b) {
+  const rank = new Map()
+  for (const obj of [a, b]) {
+    const ks = Object.keys(obj)
+    for (let i = 0; i < ks.length; i++) {
+      const k = ks[i]
+      if (k in base) continue
+      const prev = rank.get(k)
+      if (prev === undefined || i < prev) rank.set(k, i)
+    }
+  }
+  const added = [...rank.keys()].sort((x, y) => (rank.get(x) - rank.get(y)) || (x < y ? -1 : x > y ? 1 : 0))
+  return [...Object.keys(base), ...added]
+}
+
+// Value-wise 3-way merge. Fills `conflicts` (path strings) and `resolvable`
+// ({key, base, ours, theirs} with pretty-printed values) on same-path clashes;
+// the merged value keeps BASE at conflicted paths (the engine refuses the whole
+// merge when conflicts exist, so nothing partial ever ships).
+function mergeVal(base, a, b, path, conflicts, resolvable) {
+  if (eq(a, b)) return a
+  if (eq(a, base)) return b
+  if (eq(b, base)) return a
+  if (isObj(base) && isObj(a) && isObj(b)) {
+    const out = {}
+    for (const k of unionKeys(base, a, b)) {
+      const p = path ? path + '.' + k : k
+      const inB = k in base, inA = k in a, inBb = k in b
+      if (inB && !inA && !inBb) continue                                     // deleted on both sides
+      if (inB && !inA) {                                                     // ours deleted it
+        if (eq(b[k], base[k])) continue                                      // theirs untouched -> deletion wins
+        conflicts.push(p); resolvable.push(resUnit(p, base[k], undefined, b[k])); continue
+      }
+      if (inB && !inBb) {                                                    // theirs deleted it
+        if (eq(a[k], base[k])) continue
+        conflicts.push(p); resolvable.push(resUnit(p, base[k], a[k], undefined)); continue
+      }
+      if (!inB && inA && inBb) {                                             // both added
+        if (eq(a[k], b[k])) { out[k] = a[k]; continue }
+        if (isObj(a[k]) && isObj(b[k])) { out[k] = mergeVal({}, a[k], b[k], p, conflicts, resolvable); continue }
+        conflicts.push(p); resolvable.push(resUnit(p, undefined, a[k], b[k])); continue
+      }
+      if (!inB) { out[k] = inA ? a[k] : b[k]; continue }                     // one side added
+      out[k] = mergeVal(base[k], a[k], b[k], p, conflicts, resolvable)       // present everywhere
+    }
+    return out
+  }
+  if (Array.isArray(base) && Array.isArray(a) && Array.isArray(b)) {
+    const m = mergeArray(base, a, b)
+    if (m) return m
+    conflicts.push(path || '(root)'); resolvable.push(resUnit(path || '(root)', base, a, b))
+    return base
+  }
+  conflicts.push(path || '(root)')                                            // scalar/shape clash
+  resolvable.push(resUnit(path || '(root)', base, a, b))
+  return base
+}
+
+const show = (v) => (v === undefined ? '(deleted)' : JSON.stringify(v, null, 2))
+const resUnit = (p, base, ours, theirs) => ({ key: 'json:' + p, base: show(base), ours: show(ours), theirs: show(theirs) })
+
+export const json = {
+  id: 'json',
+  exts: ['.json'],
+  parses: (src) => { try { JSON.parse(String(src == null ? '' : src)); return true } catch { return false } },
+  // The engine's whole-document tier: merge the file as parsed data.
+  mergeWhole: (base, a, b) => {
+    if (!numbersSafe(base) || !numbersSafe(a) || !numbersSafe(b)) return null // precision hazard → safe fallback, never corrupt
+    let B, A, Bb
+    try { B = JSON.parse(base); A = JSON.parse(a); Bb = JSON.parse(b) } catch { return null }
+    const conflicts = [], resolvable = []
+    const merged = mergeVal(B, A, Bb, '', conflicts, resolvable)
+    if (conflicts.length) return { conflicts, resolvable }
+    const nl = /\n$/.test(base) || /\n$/.test(a) ? '\n' : ''
+    return { text: JSON.stringify(merged, null, detectIndent(base)) + nl }
+  },
+  // Minimal unit view (whole document) so generic engine paths stay well-defined;
+  // real merging happens in mergeWhole above.
+  units: (src) => [{ key: 'doc', text: String(src), start: 0, end: String(src).length }],
+  declaredNames: () => new Set(),
+  // INTENT RESOLUTION for data: a conflicted unit's "text" is a rendering of a parsed
+  // VALUE, so a judge's reconciliation is applied by setting the value at the unit's
+  // path (key 'json:<path>'), not by string replacement. The reconciled string must
+  // itself be valid JSON ('(deleted)' removes the key). Returns the re-serialized
+  // document, or null when it can't apply — resolveMerge then falls back to the safe
+  // conflict, so a malformed judgment never ships.
+  applyResolution: (text, unit, reconciled) => {
+    if (!unit || typeof unit.key !== 'string' || !unit.key.startsWith('json:')) return null
+    if (!numbersSafe(text)) return null // same precision gate: never re-serialize a doc we'd corrupt
+    let doc, value
+    try { doc = JSON.parse(text) } catch { return null }
+    const del = String(reconciled).trim() === '(deleted)'
+    if (!del) { try { value = JSON.parse(reconciled) } catch { return null } }
+    const path = unit.key.slice(5)
+    if (path === '(root)' || path === '') {
+      if (del) return null
+      doc = value
+    } else {
+      const parts = path.split('.')
+      let cur = doc
+      for (let i = 0; i < parts.length - 1; i++) {
+        if (cur == null || typeof cur !== 'object') return null
+        if (!(parts[i] in cur)) cur[parts[i]] = {}
+        cur = cur[parts[i]]
+      }
+      if (cur == null || typeof cur !== 'object') return null
+      const leaf = parts[parts.length - 1]
+      if (del) delete cur[leaf]
+      else cur[leaf] = value
+    }
+    const nl = /\n$/.test(text) ? '\n' : ''
+    return JSON.stringify(doc, null, detectIndent(text)) + nl
+  },
+}