hivecode-mcp 0.8.0 → 0.11.0

package/lang-ruby.js

@@ -0,0 +1,230 @@
+// Ruby language provider for ICR — keyword-nesting structural splitter (def/class/
+// module … end). Same honest-heuristic contract as the brace/python providers: not a
+// full parser, but conservative — anything it can't confidently structure falls back
+// to the engine's safe line tier, so output is never MORE broken than the inputs.
+//
+// Structure model: a line-oriented scan tracking strings, comments (# and =begin/=end),
+// bracket depth, and KEYWORD depth (def/class/module/if/while/… open; `end` closes).
+// Top-level def/class/module blocks become keyed units; the intent layer (dangling
+// refs, rename + call-site rewrite, token merge) rides on a lexer like Python's.
+
+function scannerAt(src) {
+  const n = src.length
+  return function at(i) {
+    if (src[i] === '#') { let j = i + 1; while (j < n && src[j] !== '\n') j++; return j }
+    if (src[i] === '"' || src[i] === "'") {
+      const q = src[i]; let j = i + 1
+      while (j < n) { if (src[j] === '\\') { j += 2; continue } if (src[j] === q) { j++; break } j++ }
+      return j
+    }
+    return -1
+  }
+}
+
+// Per physical line: the line's CODE text (strings/comments blanked), its bracket
+// delta, and byte range. =begin/=end block comments are whole-line constructs.
+function codeLines(src) {
+  const at = scannerAt(src)
+  const out = []
+  let i = 0, inBlockComment = false
+  const n = src.length
+  while (i < n) {
+    let e = src.indexOf('\n', i); e = e < 0 ? n : e + 1
+    const raw = src.slice(i, e)
+    if (inBlockComment) {
+      if (/^=end\b/.test(raw)) inBlockComment = false
+      out.push({ start: i, end: e, code: '', brackets: 0 })
+      i = e; continue
+    }
+    if (/^=begin\b/.test(raw)) { inBlockComment = true; out.push({ start: i, end: e, code: '', brackets: 0 }); i = e; continue }
+    let code = '', k = i, brackets = 0
+    while (k < e) {
+      const j = at(k)
+      if (j > k) { if (src[k] !== '#') code += ' '; k = Math.min(e, j); continue }
+      const c = src[k]
+      if (c === '(' || c === '[' || c === '{') brackets++
+      else if (c === ')' || c === ']' || c === '}') brackets--
+      code += c; k++
+    }
+    out.push({ start: i, end: e, code, brackets })
+    i = e
+  }
+  return out
+}
+
+// Keyword depth delta for one line of CODE. Conservative rules for the ambiguous
+// keywords (modifier `x if y` does not open; `while … do` opens once, not twice;
+// endless `def foo = expr` does not open).
+const OPENERS = new Set(['if', 'unless', 'while', 'until', 'case', 'begin', 'for'])
+function keywordDelta(code) {
+  const words = code.match(/[A-Za-z_]\w*[?!]?/g) || []
+  let d = 0
+  const trimmed = code.trim()
+  const endless = /\bdef\s+[A-Za-z_][\w.?!]*(\([^)]*\))?\s*=(?!=)/.test(code)
+  const hasLoop = /\b(while|until|for)\b/.test(code)
+  for (let w = 0; w < words.length; w++) {
+    const word = words[w]
+    if (word === 'def') { if (!endless) d++ }
+    else if (word === 'class' || word === 'module') d++
+    else if (OPENERS.has(word)) {
+      // statement position only: first word of the line, or right after an assignment
+      const isFirst = trimmed.startsWith(word)
+      const afterAssign = new RegExp('=\\s*' + word + '\\b').test(code)
+      if (word === 'while' || word === 'until' || word === 'for') { if (isFirst) d++ }
+      else if (isFirst || afterAssign) d++
+    }
+    else if (word === 'do') { if (!hasLoop) d++ }
+    else if (word === 'end') d--
+  }
+  return d
+}
+
+const HEAD = /^\s*(def)\s+(self\.)?([A-Za-z_][\w.?!]*)/
+const CONT = /^\s*(class|module)\s+(?:<<\s*self|([A-Z]\w*(?:::[A-Z]\w*)*))/
+
+function keyOf(text) {
+  let m = text.match(HEAD); if (m) return 'def:' + (m[2] || '') + m[3]
+  m = text.match(CONT); if (m) return m[1] + ':' + (m[2] || 'self')
+  return 'stmt:' + text.split('\n')[0].trim().replace(/\s+/g, ' ')
+}
+
+// Units over a region: a def/class/module head at keyword-depth 0 owns everything
+// until its matching `end`; other depth-0 lines are statements (joined while
+// brackets stay open).
+function blocks(src) {
+  const L = codeLines(src)
+  const units = []
+  let i = 0
+  while (i < L.length) {
+    while (i < L.length && L[i].code.trim() === '') i++
+    if (i >= L.length) break
+    const start = L[i].start
+    const head = L[i].code
+    if (/^\s*(def|class|module)\b/.test(head)) {
+      let depth = 0, brackets = 0
+      do {
+        depth += keywordDelta(L[i].code)
+        brackets += L[i].brackets
+        i++
+      } while (i < L.length && (depth > 0 || brackets > 0))
+      units.push({ start, end: L[i - 1].end })
+    } else {
+      let brackets = L[i].brackets, depth = keywordDelta(L[i].code)
+      i++
+      while (i < L.length && (brackets > 0 || depth > 0)) { brackets += L[i].brackets; depth += keywordDelta(L[i].code); i++ }
+      units.push({ start, end: L[i - 1].end })
+    }
+  }
+  return units
+}
+
+function keyed(raw, src) {
+  const seen = new Map(), out = []
+  for (const u of raw) {
+    const text = src.slice(u.start, u.end)
+    let k = keyOf(text)
+    const c = (seen.get(k) || 0) + 1; seen.set(k, c)
+    if (c > 1) k += '#' + c
+    out.push({ key: k, text, start: u.start, end: u.end })
+  }
+  return out
+}
+
+// Approximate parse: brackets balanced AND keyword nesting closes exactly
+// (never negative, ends at zero) AND no unterminated block comment.
+function wellNested(src) {
+  const L = codeLines(src)
+  let depth = 0, brackets = 0
+  for (const l of L) {
+    depth += keywordDelta(l.code)
+    brackets += l.brackets
+    if (depth < 0 || brackets < 0) return false
+  }
+  return depth === 0 && brackets === 0
+}
+
+// Lexer for the intent layer + token merge (comments in gaps, strings one token).
+function lexTokens(src) {
+  const at = scannerAt(src)
+  const out = []
+  const n = src.length
+  let i = 0
+  while (i < n) {
+    const c = src[i]
+    if (c === ' ' || c === '\t' || c === '\r' || c === '\n') { i++; continue }
+    const j = at(i)
+    if (j > i) {
+      if (c === '#') { i = j; continue }
+      out.push({ start: i, end: j, k: src.slice(i, j) }); i = j; continue
+    }
+    if (/[A-Za-z_]/.test(c)) { let e = i + 1; while (e < n && /\w/.test(src[e])) e++; if (src[e] === '?' || src[e] === '!') e++; out.push({ start: i, end: e, k: src.slice(i, e) }); i = e; continue }
+    if (/[0-9]/.test(c)) { let e = i + 1; while (e < n && /[\w.]/.test(src[e])) e++; out.push({ start: i, end: e, k: src.slice(i, e) }); i = e; continue }
+    out.push({ start: i, end: i + 1, k: c }); i++
+  }
+  return out
+}
+
+// Reference position: not `.name` (method call on receiver) — `:name` symbols DO
+// count (send(:helper) is a real reference; over-inclusion is the cautious direction).
+function isRefToken(src, t) {
+  if (!/^[A-Za-z_]\w*[?!]?$/.test(t.k)) return false
+  let p = t.start - 1
+  while (p >= 0 && (src[p] === ' ' || src[p] === '\t')) p--
+  return !(p >= 0 && src[p] === '.')
+}
+
+export const ruby = {
+  id: 'ruby',
+  exts: ['.rb', '.rake'],
+  parses: (src) => wellNested(String(src == null ? '' : src)),
+  parsesUnit: (src) => wellNested(String(src)),
+  units: (src) => keyed(blocks(String(src)), String(src)),
+  declaredNames: (src) => {
+    const names = new Set()
+    for (const u of keyed(blocks(String(src)), String(src))) {
+      const m = u.key.match(/^(?:def|class|module):(?:self\.)?([A-Za-z_][\w.?!]*)/)
+      if (m) names.add(m[1])
+    }
+    return names
+  },
+  usedIdentifiers: (src) => {
+    src = String(src)
+    const used = new Set()
+    for (const t of lexTokens(src)) if (isRefToken(src, t)) used.add(t.k)
+    return used
+  },
+  declBody: (src, name) => {
+    src = String(src)
+    for (const u of keyed(blocks(src), src)) {
+      const m = u.key.match(/^(?:def|class|module):(?:self\.)?([A-Za-z_][\w.?!]*)/)
+      if (!m || m[1] !== name) continue
+      return u.text.replace(name, '').trimEnd()
+    }
+    return null
+  },
+  renameRefs: (src, oldName, newName) => {
+    src = String(src)
+    const spots = []
+    for (const t of lexTokens(src)) if (t.k === oldName && isRefToken(src, t)) spots.push(t)
+    let out = src
+    for (const t of spots.reverse()) out = out.slice(0, t.start) + newName + out.slice(t.end)
+    return out
+  },
+  tokenize: (src) => lexTokens(String(src)),
+  // Descend into a class/module so two agents editing DIFFERENT methods merge.
+  splitUnit: (text) => {
+    const src = String(text)
+    if (!/^\s*(class|module)\b/.test(src)) return null
+    const L = codeLines(src)
+    if (!L.length) return null
+    const sigEnd = L[0].end
+    // body = everything between the header line and the final matching `end` line
+    let last = L.length - 1
+    while (last > 0 && L[last].code.trim() === '') last--
+    if (!/^\s*end\b/.test(L[last].code)) return null
+    const bodyStart = sigEnd, bodyEnd = L[last].start
+    const body = src.slice(bodyStart, bodyEnd)
+    const inner = keyed(blocks(body), body)
+    return { sig: src.slice(0, sigEnd), open: '', close: src.slice(bodyEnd), body, units: inner, join: '', spliceable: true }
+  },
+}

package/lang-toml.js

@@ -0,0 +1,136 @@
+// TOML language provider for ICR — section/key structural splitter.
+// Cargo.toml / pyproject.toml are constantly edited concurrently (two people add
+// dependencies). This provider merges by STRUCTURE: every `[section]` (and
+// `[[array-of-tables]]`) is a unit keyed by its name; keys in the top-level
+// preamble are units of their own; splitUnit descends into a section so two
+// edits to DIFFERENT keys of the same table merge cleanly.
+//
+// Honest heuristic: tracks #-comments and single/double/triple-quoted strings;
+// parses() = balanced delimiters + well-formed section headers.
+
+function scannerAt(src) {
+  const n = src.length
+  return function at(i) {
+    if (src[i] === '#') { let j = i + 1; while (j < n && src[j] !== '\n') j++; return j }
+    for (const q of ['"""', "'''"]) if (src.startsWith(q, i)) { let j = i + 3; while (j < n && !src.startsWith(q, j)) { if (src[j] === '\\') j++; j++ } return Math.min(n, j + 3) }
+    if (src[i] === '"' || src[i] === "'") {
+      const q = src[i]; let j = i + 1
+      while (j < n) { if (q === '"' && src[j] === '\\') { j += 2; continue } if (src[j] === q) { j++; break } if (src[j] === '\n') break; j++ }
+      return j
+    }
+    return -1
+  }
+}
+
+function lines(src) {
+  const out = []
+  let i = 0
+  while (i < src.length) {
+    let e = src.indexOf('\n', i); e = e < 0 ? src.length : e + 1
+    const body = src.slice(i, e).replace(/\r?\n$/, '')
+    const trimmed = body.trim()
+    out.push({ start: i, end: e, blank: trimmed === '' || trimmed.startsWith('#'), text: body })
+    i = e
+  }
+  return out
+}
+
+const SECTION = /^\s*(\[\[?)([^\]]+)\]\]?\s*(#.*)?$/
+const KEYLINE = /^\s*([A-Za-z0-9_."'-]+)\s*=/
+
+// Bracket delta for one line, string/comment aware (multi-line arrays continue a key).
+function bracketDelta(src, at, s, e) {
+  let d = 0, k = s
+  while (k < e) {
+    const j = at(k); if (j > k) { k = Math.min(e, j); continue }
+    const c = src[k]
+    if (c === '[' || c === '{') d++
+    else if (c === ']' || c === '}') d--
+    k++
+  }
+  return d
+}
+
+// Top-level units: a [section] header owns everything until the next header;
+// preamble `key = value` lines are individual units (multi-line values included).
+function blocks(src) {
+  const at = scannerAt(src)
+  const L = lines(src)
+  const units = []
+  let i = 0
+  while (i < L.length) {
+    while (i < L.length && L[i].text.trim() === '') i++
+    if (i >= L.length) break
+    const start = L[i].start
+    while (i < L.length && L[i].blank && L[i].text.trim().startsWith('#')) i++ // leading comments attach
+    if (i >= L.length) { units.push({ start, end: L[L.length - 1].end }); break }
+    if (SECTION.test(L[i].text)) {
+      i++ // header
+      while (i < L.length && !SECTION.test(L[i].text)) i++
+      let last = i - 1
+      while (last >= 0 && L[last].text.trim() === '') last--
+      units.push({ start, end: L[last].end })
+    } else {
+      // one key (or stray statement); consume continuation lines while brackets open
+      let depth = bracketDelta(src, at, L[i].start, L[i].end)
+      let e = L[i].end; i++
+      while (i < L.length && depth > 0) { depth += bracketDelta(src, at, L[i].start, L[i].end); e = L[i].end; i++ }
+      units.push({ start, end: e })
+    }
+  }
+  return units
+}
+
+function keyOf(text) {
+  const head = text.split('\n').find((l) => l.trim() && !l.trim().startsWith('#')) || text
+  let m = head.match(SECTION); if (m) return (m[1] === '[[' ? 'tables:' : 'table:') + m[2].trim()
+  m = head.match(KEYLINE); if (m) return 'key:' + m[1].replace(/["']/g, '')
+  return 'stmt:' + head.trim().replace(/\s+/g, ' ')
+}
+
+function keyed(raw, src) {
+  const seen = new Map(), out = []
+  for (const u of raw) {
+    const text = src.slice(u.start, u.end)
+    let k = keyOf(text)
+    const c = (seen.get(k) || 0) + 1; seen.set(k, c)
+    if (c > 1) k += '#' + c
+    out.push({ key: k, text, start: u.start, end: u.end })
+  }
+  return out
+}
+
+function balanced(src) {
+  const at = scannerAt(src)
+  const stack = []
+  const pair = { ']': '[', '}': '{' }
+  let i = 0
+  while (i < src.length) {
+    const j = at(i); if (j > i) { if (j > src.length) return false; i = j; continue }
+    const c = src[i]
+    if (c === '[' || c === '{') stack.push(c)
+    else if (pair[c]) { if (stack.pop() !== pair[c]) return false }
+    i++
+  }
+  return stack.length === 0
+}
+
+export const toml = {
+  id: 'toml',
+  exts: ['.toml'],
+  parses: (src) => balanced(String(src == null ? '' : src)),
+  parsesUnit: (src) => balanced(String(src)),
+  units: (src) => keyed(blocks(String(src)), String(src)),
+  declaredNames: () => new Set(),
+  // Descend into a section: each `key = value` inside merges independently.
+  splitUnit: (text) => {
+    const src = String(text)
+    const L = lines(src)
+    let h = 0; while (h < L.length && L[h].blank) h++
+    if (h >= L.length || !SECTION.test(L[h].text)) return null
+    const sig = src.slice(0, L[h].end)
+    const body = src.slice(L[h].end)
+    const inner = keyed(blocks(body), body)
+    return { sig, open: '', close: '', body, units: inner, join: '', spliceable: true }
+  },
+}

package/lang-yaml.js

@@ -0,0 +1,151 @@
+// YAML language provider for ICR — indent-mapping structural splitter.
+// YAML configs (CI pipelines, k8s manifests, docker-compose) are merged constantly
+// and line merges garble them. This provider merges by STRUCTURE: every top-level
+// `key:` block is a unit keyed by its key name, and splitUnit descends into nested
+// mapping levels — so two people editing DIFFERENT jobs/services/sections merge
+// cleanly, and the SAME key edited two ways is a named conflict.
+//
+// Honest heuristic (no parser dependency): tracks #-comments, quoted strings, and
+// flow brackets; parses() checks bracket balance + indentation coherence (a dedent
+// must land on an indent level that exists — the failure mode of a bad splice).
+// Block scalars (|, >) are tolerated: their content is deeper-indented free text.
+
+function scannerAt(src) {
+  const n = src.length
+  return function at(i) {
+    if (src[i] === '#') { let j = i + 1; while (j < n && src[j] !== '\n') j++; return j }
+    if (src[i] === '"' || src[i] === "'") {
+      const q = src[i]; let j = i + 1
+      while (j < n) { if (q === '"' && src[j] === '\\') { j += 2; continue } if (src[j] === q) { j++; break } if (src[j] === '\n') break; j++ }
+      return j
+    }
+    return -1
+  }
+}
+
+// Line records with indent; comment-only and blank lines are marked.
+function lines(src) {
+  const out = []
+  let i = 0
+  while (i < src.length) {
+    let e = src.indexOf('\n', i); e = e < 0 ? src.length : e + 1
+    const raw = src.slice(i, e)
+    const body = raw.replace(/\r?\n$/, '')
+    let indent = 0; while (indent < body.length && body[indent] === ' ') indent++
+    const trimmed = body.trim()
+    out.push({ start: i, end: e, indent, blank: trimmed === '' || trimmed.startsWith('#'), text: body })
+    i = e
+  }
+  return out
+}
+
+const KEY = /^([^:#\s][^:#]*?):(\s|$)/     // `key:` or `key: value`
+const DASH = /^-(\s|$)/                    // list item
+
+function keyOf(text) {
+  const t = text.trim()
+  const m = t.match(KEY)
+  if (m) return 'key:' + m[1].trim()
+  if (t === '---' || t === '...') return 'doc:' + t
+  return 'stmt:' + t.replace(/\s+/g, ' ')
+}
+
+// Units whose heads sit at exactly `baseIndent`: a `key:`/`- ` head owns all
+// following blank or deeper-indented lines (its block).
+function blocks(src, baseIndent = 0) {
+  const L = lines(src)
+  const units = []
+  let i = 0
+  while (i < L.length) {
+    while (i < L.length && L[i].text.trim() === '') i++ // pure blanks are gap text
+    if (i >= L.length) break
+    const start = L[i].start
+    // leading comment lines attach to the unit that follows
+    while (i < L.length && L[i].blank && L[i].text.trim().startsWith('#')) i++
+    if (i >= L.length) { units.push({ start, end: L[L.length - 1].end }); break }
+    if (L[i].indent !== baseIndent) { units.push({ start, end: L[i].end }); i++; continue }
+    i++ // the head line
+    while (i < L.length && (L[i].blank || L[i].indent > baseIndent)) i++
+    let last = i - 1
+    while (last >= 0 && L[last].text.trim() === '') last-- // trailing blanks are gap text
+    units.push({ start, end: L[last].end })
+  }
+  return units
+}
+
+function keyed(raw, src) {
+  const seen = new Map(), out = []
+  for (const u of raw) {
+    const text = src.slice(u.start, u.end)
+    // key by the HEAD line (skipping attached leading comments)
+    const head = text.split('\n').find((l) => l.trim() && !l.trim().startsWith('#')) || text
+    let k = keyOf(head)
+    const c = (seen.get(k) || 0) + 1; seen.set(k, c)
+    if (c > 1) k += '#' + c
+    out.push({ key: k, text, start: u.start, end: u.end })
+  }
+  return out
+}
+
+// Bracket balance (flow style) + unterminated-string detection.
+function balanced(src) {
+  const at = scannerAt(src)
+  const stack = []
+  const pair = { ')': '(', ']': '[', '}': '{' }
+  let i = 0
+  while (i < src.length) {
+    const j = at(i); if (j > i) { if (j > src.length) return false; i = j; continue }
+    const c = src[i]
+    if (c === '(' || c === '[' || c === '{') stack.push(c)
+    else if (pair[c]) { if (stack.pop() !== pair[c]) return false }
+    i++
+  }
+  return stack.length === 0
+}
+
+// Indentation coherence: an indent INCREASE opens a new level (always legal in YAML —
+// nested mapping, list, or block-scalar content); a DECREASE must land on a level
+// that is already on the stack. This is exactly what a bad merge splice violates.
+function indentsOk(src) {
+  const L = lines(src)
+  let stack = null
+  for (const l of L) {
+    if (l.blank) continue
+    if (stack == null) { stack = [l.indent]; continue }
+    const top = stack[stack.length - 1]
+    if (l.indent > top) { stack.push(l.indent); continue }
+    if (l.indent < top) {
+      while (stack.length > 1 && stack[stack.length - 1] > l.indent) stack.pop()
+      if (stack[stack.length - 1] !== l.indent) return false
+    }
+  }
+  return true
+}
+
+export const yaml = {
+  id: 'yaml',
+  exts: ['.yml', '.yaml'],
+  parses: (src) => { const s = String(src == null ? '' : src); return balanced(s) && indentsOk(s) },
+  parsesUnit: (src) => { const s = String(src); return balanced(s) && indentsOk(s) },
+  units: (src) => keyed(blocks(String(src), 0), String(src)),
+  declaredNames: () => new Set(), // keys are structure, not code declarations
+  // Descend one mapping level: `jobs:` -> each job merges independently.
+  splitUnit: (text) => {
+    const src = String(text)
+    const L = lines(src)
+    let h = 0; while (h < L.length && L[h].blank) h++
+    if (h >= L.length) return null
+    const head = L[h]
+    if (!KEY.test(head.text.trim())) return null
+    if (head.text.trim().match(/:\s*[|>][+-]?\s*(#.*)?$/)) return null // block scalar: free text, do not descend
+    if (!/:\s*(#.*)?$/.test(head.text)) return null                    // inline value (`key: v`): nothing beneath
+    let b = h + 1; while (b < L.length && L[b].blank) b++
+    if (b >= L.length || L[b].indent <= head.indent) return null       // empty block
+    const bodyIndent = L[b].indent
+    const sig = src.slice(0, L[h].end)
+    const body = src.slice(L[h].end)
+    const inner = keyed(blocks(body, bodyIndent), body)
+    if (inner.some((u) => u.key.startsWith('stmt:-') || DASH.test(u.text.trim()))) return null // list items: order matters, stay whole
+    return { sig, open: '', close: '', body, units: inner, join: '', spliceable: true }
+  },
+}