hivecode-mcp 0.8.0 → 0.11.1

package/lang-json.js

@@ -0,0 +1,184 @@
+// 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
+}
+
+// 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 = {}
+    const keys = [...new Set([...Object.keys(base), ...Object.keys(a), ...Object.keys(b)])]
+    for (const k of keys) {
+      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
+  },
+}