hivecode-mcp 0.6.0 → 0.8.0

package/lang-js.js

@@ -0,0 +1,418 @@
+// lang-js.js — the JavaScript language provider for ICR.
+//
+// ICR's merge engine (icr.js) is language-agnostic: it merges a list of keyed "units"
+// and asks intent questions ("what names are declared / used / what's a function body").
+// Everything that actually knows about a *language* — how to parse it, what a top-level
+// declaration is, how to find references — lives behind a provider like this one.
+//
+// To add a language (Python, Go, Rust…), write another module exposing the same shape
+// and register it with icr.js's registerLanguage(). This JS provider is just the first
+// plugin; it happens to use `acorn` because acorn is a tiny pure-JS parser. A tree-sitter
+// provider would implement the identical interface over tree-sitter grammars.
+
+import * as acorn from 'acorn'
+
+// Parse permissively: try module syntax, fall back to script (so plain snippets and
+// ESM both work). Throws only when the code genuinely won't parse either way.
+function parse(src) {
+  try { return acorn.parse(src, { ecmaVersion: 'latest', sourceType: 'module' }) }
+  catch { return acorn.parse(src, { ecmaVersion: 'latest', sourceType: 'script' }) }
+}
+
+function parses(src) { try { parse(src); return true } catch { return false } }
+
+// A stable key per top-level node — what lets us recognize "the same declaration"
+// across two edits. Names where we have them; position as a last resort.
+function keyOf(node, i) {
+  let n = node
+  if (n.type === 'ExportNamedDeclaration' && n.declaration) n = n.declaration
+  if (n.type === 'ExportDefaultDeclaration') return 'export:default'
+  if (n.type === 'FunctionDeclaration' && n.id) return 'fn:' + n.id.name
+  if (n.type === 'ClassDeclaration' && n.id) return 'class:' + n.id.name
+  if (n.type === 'VariableDeclaration' && n.declarations[0] && n.declarations[0].id && n.declarations[0].id.name)
+    return 'var:' + n.declarations[0].id.name
+  // Key imports by their SOURCE MODULE, so two agents adding imports from DIFFERENT
+  // modules never collide, and two touching the SAME module are merged (specifier union).
+  if (n.type === 'ImportDeclaration') return 'import:' + (n.source && n.source.value != null ? n.source.value : i)
+  return 'stmt:' + i
+}
+
+// Top-level units: ordered { key, text, start, end } for each declaration/statement.
+// start/end are byte offsets in `src` — used by the format-preserving splice so unchanged
+// regions (and the whitespace/comments between units) survive a merge verbatim.
+function units(src) {
+  const ast = parse(src)
+  return ast.body.map((node, i) => ({ key: keyOf(node, i), text: src.slice(node.start, node.end), start: node.start, end: node.end }))
+}
+
+// Bare declared name (foo, Bar, VERSION) of a node, or null for anonymous statements.
+function bareName(node) {
+  let n = node
+  if (n.type === 'ExportNamedDeclaration' && n.declaration) n = n.declaration
+  if (n.type === 'FunctionDeclaration' && n.id) return n.id.name
+  if (n.type === 'ClassDeclaration' && n.id) return n.id.name
+  if (n.type === 'VariableDeclaration' && n.declarations[0] && n.declarations[0].id && n.declarations[0].id.name) return n.declarations[0].id.name
+  return null
+}
+
+function declaredNames(src) {
+  const s = new Set()
+  for (const node of parse(src).body) {
+    const nm = bareName(node); if (nm) s.add(nm)
+    // Import locals count as declared names too — so if an import is ever dropped and its
+    // binding is still used, the dangling-reference check catches it (safety net for the
+    // import merge). Keeps the never-emit-broken-code guarantee honest for imports.
+    if (node.type === 'ImportDeclaration') for (const sp of node.specifiers) s.add(sp.local.name)
+  }
+  return s
+}
+
+// --- import-aware merging -------------------------------------------------------
+// Parse a single import statement into its parts, or null if it isn't one.
+function parseImport(src) {
+  let n
+  try { n = parse(src).body[0] } catch { return null }
+  if (!n || n.type !== 'ImportDeclaration') return null
+  let def = null, ns = null
+  const named = []
+  for (const sp of n.specifiers) {
+    if (sp.type === 'ImportDefaultSpecifier') def = sp.local.name
+    else if (sp.type === 'ImportNamespaceSpecifier') ns = sp.local.name
+    else named.push({ imported: sp.imported.name != null ? sp.imported.name : sp.imported.value, local: sp.local.name })
+  }
+  return { source: n.source.value, def, ns, named }
+}
+function renderImport({ source, def, ns, named }) {
+  const parts = []
+  if (def) parts.push(def)
+  if (ns) parts.push('* as ' + ns)
+  if (named.length) parts.push('{ ' + named.map((s) => s.imported === s.local ? s.local : s.imported + ' as ' + s.local).join(', ') + ' }')
+  if (!parts.length) return "import '" + source + "'"
+  return 'import ' + parts.join(', ') + " from '" + source + "'"
+}
+// Both sides changed an import from the SAME module → union their specifiers into one
+// statement (the common "both agents added an import" case). Returns null — meaning
+// "let the normal conflict path handle it" — for anything we can't safely combine
+// (different modules, clashing defaults/namespaces, namespace-mixed-with-named).
+function mergeUnit(baseText, aText, bText) {
+  const a = parseImport(aText), b = parseImport(bText)
+  if (!a || !b || a.source !== b.source) return null
+  let def
+  if (a.def && b.def) { if (a.def !== b.def) return null; def = a.def } else def = a.def || b.def
+  let ns
+  if (a.ns && b.ns) { if (a.ns !== b.ns) return null; ns = a.ns } else ns = a.ns || b.ns
+  if (ns && (a.named.length || b.named.length)) return null // `* as X` can't share a statement with named imports
+  const seen = new Set(), named = []
+  for (const s of [...a.named, ...b.named]) { const k = s.imported + '|' + s.local; if (!seen.has(k)) { seen.add(k); named.push(s) } }
+  return renderImport({ source: a.source, def, ns, named })
+}
+
+// The BODY of a top-level declaration, by name, with the name itself excluded — so two
+// declarations that differ only in their name compare equal (that's how we spot a rename).
+function declBody(src, name) {
+  for (const node of parse(src).body) {
+    if (bareName(node) !== name) continue
+    let n = node
+    if (n.type === 'ExportNamedDeclaration' && n.declaration) n = n.declaration
+    if ((n.type === 'FunctionDeclaration' || n.type === 'ClassDeclaration') && n.body)
+      return src.slice(n.body.start, n.body.end)
+    if (n.type === 'VariableDeclaration' && n.declarations[0] && n.declarations[0].init) {
+      const init = n.declarations[0].init
+      return src.slice(init.start, init.end)
+    }
+    return null
+  }
+  return null
+}
+
+// Rewrite every reference to `oldName` as `newName` (skipping property/key positions,
+// which aren't references to the declaration). Edits back-to-front to keep offsets valid.
+function renameRefs(src, oldName, newName) {
+  const spots = []
+  walk(parse(src), (node, parent, key) => {
+    if (node.type !== 'Identifier' || node.name !== oldName) return
+    if (parent && parent.type === 'MemberExpression' && key === 'property' && !parent.computed) return
+    if (parent && (parent.type === 'Property' || parent.type === 'PropertyDefinition') && key === 'key' && !parent.computed) return
+    spots.push([node.start, node.end])
+  })
+  spots.sort((a, b) => b[0] - a[0])
+  let out = src
+  for (const [s, e] of spots) out = out.slice(0, s) + newName + out.slice(e)
+  return out
+}
+
+// Every identifier USED anywhere (skips obj.prop names and non-computed object keys).
+// Approximate — good enough for the intent check; the real version is scope-aware.
+function usedIdentifiers(src) {
+  const used = new Set()
+  walk(parse(src), (node, parent, key) => {
+    if (node.type !== 'Identifier') return
+    if (parent && parent.type === 'MemberExpression' && key === 'property' && !parent.computed) return
+    if (parent && (parent.type === 'Property' || parent.type === 'PropertyDefinition') && key === 'key' && !parent.computed) return
+    used.add(node.name)
+  })
+  return used
+}
+
+function walk(node, visit, parent = null, key = null) {
+  if (!node || typeof node.type !== 'string') return
+  visit(node, parent, key)
+  for (const k of Object.keys(node)) {
+    if (k === 'type' || k === 'start' || k === 'end' || k === 'loc') continue
+    const v = node[k]
+    if (Array.isArray(v)) { for (const c of v) walk(c, visit, node, k) }
+    else if (v && typeof v.type === 'string') walk(v, visit, node, k)
+  }
+}
+
+// --- scope-aware reference analysis ---------------------------------------------
+// The names REFERENCED in `src` that resolve to NOTHING in the file's own scopes —
+// i.e. free/global names, including any use of a top-level declaration. This is the
+// scope-aware upgrade of usedIdentifiers: a use of `x` that resolves to a LOCAL binding
+// (a param, a `const x` in the same function, a catch var, a loop var…) is NOT counted,
+// because it isn't a reference to a top-level declaration. That lets ICR tell a deleted
+// top-level `helper` apart from an unrelated local `helper` that merely shares its name.
+//
+// Honest scope coverage: functions (declaration/expression/arrow), blocks, catch
+// clauses, for/for-in/for-of loop bindings, params with simple destructuring, imports,
+// var-hoisting to the function scope, and let/const/class/function block binding.
+// Approximations (rare, and they only ever make the dangling check MORE cautious):
+// default-value expressions in patterns and `with`/eval are not modeled.
+// Walk the AST and call emit(identifierNode) for every reference that resolves to NO
+// local binding (free / would resolve to module or global scope). Both the dangling-ref
+// check and scope-aware renaming are built on this single traversal.
+function walkFreeRefs(src, emit) { resolveScopes(parse(src), null, emit) }
+
+function referencedFreeNames(src) {
+  const free = new Set()
+  walkFreeRefs(src, (node) => free.add(node.name))
+  return free
+}
+
+// Rename ONLY the free references to oldName (those that resolve to the top-level/global
+// binding) — never a local variable that merely shares the name. Edits back-to-front.
+function renameFreeRefs(src, oldName, newName) {
+  const spots = []
+  walkFreeRefs(src, (node) => { if (node.name === oldName) spots.push([node.start, node.end]) })
+  spots.sort((a, b) => b[0] - a[0])
+  let out = src
+  for (const [s, e] of spots) out = out.slice(0, s) + newName + out.slice(e)
+  return out
+}
+
+const CHILD_SKIP = new Set(['type', 'start', 'end', 'loc', 'range'])
+function eachChild(node, fn) {
+  for (const k of Object.keys(node)) {
+    if (CHILD_SKIP.has(k)) continue
+    const v = node[k]
+    if (Array.isArray(v)) { for (const c of v) if (c && typeof c.type === 'string') fn(c) }
+    else if (v && typeof v.type === 'string') fn(v)
+  }
+}
+
+// Names introduced by a binding target (handles identifiers + simple destructuring).
+function bindingNames(node, out) {
+  if (!node) return
+  switch (node.type) {
+    case 'Identifier': out.add(node.name); break
+    case 'ObjectPattern': for (const p of node.properties) bindingNames(p.type === 'RestElement' ? p.argument : p.value, out); break
+    case 'ArrayPattern': for (const el of node.elements) if (el) bindingNames(el, out); break
+    case 'AssignmentPattern': bindingNames(node.left, out); break
+    case 'RestElement': bindingNames(node.argument, out); break
+  }
+}
+
+// A binding target's NAMES are bindings, but its default values (`a = expr`) and computed
+// destructuring keys (`{ [k]: v }`) are REFERENCES that must be resolved against the scope.
+// Without this, a name used only in a default value would be missed by the dangling check.
+function resolveBindingDefaults(node, scope, emit) {
+  if (!node) return
+  switch (node.type) {
+    case 'AssignmentPattern': resolveBindingDefaults(node.left, scope, emit); resolveScopes(node.right, scope, emit); break
+    case 'ObjectPattern': for (const p of node.properties) {
+      if (p.type === 'RestElement') { resolveBindingDefaults(p.argument, scope, emit); break }
+      if (p.computed) resolveScopes(p.key, scope, emit)
+      resolveBindingDefaults(p.value, scope, emit)
+    } break
+    case 'ArrayPattern': for (const el of node.elements) if (el) resolveBindingDefaults(el, scope, emit); break
+    case 'RestElement': resolveBindingDefaults(node.argument, scope, emit); break
+    // Identifier: a pure binding — nothing to resolve.
+  }
+}
+
+const makeScope = (parent, fnScope) => { const s = { vars: new Set(), parent }; s.fnScope = fnScope || s; return s }
+const resolves = (scope, name) => { for (let s = scope; s; s = s.parent) if (s.vars.has(name)) return true; return false }
+
+// Hoist var declarations + function declarations into the function scope (deep, but not
+// crossing into nested functions, which own their own var scope).
+function hoistFunctionScope(nodes, scope) { for (const n of nodes) collectHoisted(n, scope) }
+function collectHoisted(node, scope) {
+  if (!node || typeof node.type !== 'string') return
+  if (node.type === 'FunctionDeclaration') { if (node.id) scope.fnScope.vars.add(node.id.name); return }
+  if (/Function(Expression)?$|ArrowFunctionExpression/.test(node.type)) return // nested function: stop
+  if (node.type === 'VariableDeclaration' && node.kind === 'var')
+    for (const d of node.declarations) bindingNames(d.id, scope.fnScope.vars)
+  eachChild(node, (c) => collectHoisted(c, scope))
+}
+// Bind let/const/class/function/import names declared directly in a block/program.
+function hoistBlock(nodes, scope) {
+  for (const n of nodes) {
+    if (n.type === 'VariableDeclaration' && (n.kind === 'let' || n.kind === 'const'))
+      for (const d of n.declarations) bindingNames(d.id, scope.vars)
+    else if (n.type === 'ClassDeclaration' && n.id) scope.vars.add(n.id.name)
+    else if (n.type === 'FunctionDeclaration' && n.id) scope.vars.add(n.id.name)
+    else if (n.type === 'ImportDeclaration') for (const sp of n.specifiers) scope.vars.add(sp.local.name)
+  }
+}
+
+function resolveScopes(node, scope, emit) {
+  if (!node || typeof node.type !== 'string') return
+  switch (node.type) {
+    case 'Program': {
+      const s = makeScope(null, null)
+      hoistFunctionScope(node.body, s); hoistBlock(node.body, s)
+      for (const c of node.body) resolveScopes(c, s, emit)
+      return
+    }
+    case 'FunctionDeclaration': case 'FunctionExpression': case 'ArrowFunctionExpression': {
+      const s = makeScope(scope, null)
+      for (const p of node.params) bindingNames(p, s.vars)
+      for (const p of node.params) resolveBindingDefaults(p, s, emit) // default values are references
+      if (node.id && node.type === 'FunctionExpression') s.vars.add(node.id.name) // named fn expr
+      if (node.body.type === 'BlockStatement') {
+        hoistFunctionScope(node.body.body, s); hoistBlock(node.body.body, s)
+        for (const c of node.body.body) resolveScopes(c, s, emit)
+      } else resolveScopes(node.body, s, emit) // arrow with expression body
+      return
+    }
+    case 'BlockStatement': {
+      const s = makeScope(scope, scope.fnScope); hoistBlock(node.body, s)
+      for (const c of node.body) resolveScopes(c, s, emit)
+      return
+    }
+    case 'CatchClause': {
+      const s = makeScope(scope, scope.fnScope)
+      if (node.param) bindingNames(node.param, s.vars)
+      resolveScopes(node.body, s, emit)
+      return
+    }
+    case 'ForStatement': {
+      const s = makeScope(scope, scope.fnScope)
+      if (node.init && node.init.type === 'VariableDeclaration') hoistBlock([node.init], s)
+      for (const k of ['init', 'test', 'update', 'body']) if (node[k]) resolveScopes(node[k], s, emit)
+      return
+    }
+    case 'ForInStatement': case 'ForOfStatement': {
+      const s = makeScope(scope, scope.fnScope)
+      if (node.left.type === 'VariableDeclaration') hoistBlock([node.left], s)
+      else resolveScopes(node.left, s, emit)
+      resolveScopes(node.right, s, emit); resolveScopes(node.body, s, emit)
+      return
+    }
+    case 'VariableDeclarator': { resolveBindingDefaults(node.id, scope, emit); if (node.init) resolveScopes(node.init, scope, emit); return } // id is a binding (defaults are refs)
+    case 'Identifier': { if (!resolves(scope, node.name)) emit(node); return }
+    case 'MemberExpression': { resolveScopes(node.object, scope, emit); if (node.computed) resolveScopes(node.property, scope, emit); return }
+    case 'Property': { if (node.computed) resolveScopes(node.key, scope, emit); resolveScopes(node.value, scope, emit); return }
+    case 'PropertyDefinition': case 'MethodDefinition': { if (node.computed) resolveScopes(node.key, scope, emit); if (node.value) resolveScopes(node.value, scope, emit); return }
+    case 'LabeledStatement': { resolveScopes(node.body, scope, emit); return }
+    case 'BreakStatement': case 'ContinueStatement': return // labels aren't value references
+    case 'ExportSpecifier': { resolveScopes(node.local, scope, emit); return }
+    case 'ImportSpecifier': case 'ImportDefaultSpecifier': case 'ImportNamespaceSpecifier': return // binding positions
+    default: eachChild(node, (c) => resolveScopes(c, scope, emit))
+  }
+}
+
+// A stable key for a class member, so two agents editing DIFFERENT methods of the same
+// class merge, while editing the SAME method conflicts.
+function memberKey(m, i) {
+  const kind = m.type === 'MethodDefinition' ? (m.kind === 'constructor' ? 'ctor' : 'method') : 'field'
+  if (m.key && m.key.type === 'Identifier' && !m.computed)
+    return kind + ':' + (m.static ? 'static.' : '') + m.key.name
+  return 'member:' + i
+}
+
+// For finer-grained merging: split a single declaration into its signature text + keyed
+// inner units, plus how to reassemble them. Handles FUNCTIONS (body statements, keyed
+// like top-level decls) and CLASSES (members, keyed by method/field name). Returns null
+// for anything else (the engine then treats the declaration as indivisible). Tolerates
+// fragments that don't parse standalone (e.g. a bare `return`).
+const MEMBER_WRAP = 'class __ICR__{'
+// A class member (method) doesn't parse standalone — wrap it in a throwaway class so we
+// can recurse INTO a method body that both agents edited. Offsets are mapped back to src.
+function splitMember(src) {
+  let ast
+  try { ast = parse(MEMBER_WRAP + src + '}') } catch { return null }
+  const cls = ast.body[0]
+  if (!cls || cls.type !== 'ClassDeclaration' || !cls.body.body.length) return null
+  const m = cls.body.body[0]
+  if (!m || m.type !== 'MethodDefinition' || !m.value || !m.value.body || m.value.body.type !== 'BlockStatement') return null
+  const off = MEMBER_WRAP.length, body = m.value.body
+  const sig = src.slice(0, body.start - off)
+  const units = body.body.map((s, i) => ({ key: keyOf(s, i), text: src.slice(s.start - off, s.end - off) }))
+  return { sig, units, open: '{\n  ', join: '\n  ', close: '\n}' }
+}
+
+function splitUnit(src) {
+  let ast
+  try { ast = parse(src) } catch { return splitMember(src) } // maybe a class-member fragment
+  let n = ast.body[0]
+  if (!n) return null
+  if (n.type === 'ExportNamedDeclaration' && n.declaration) n = n.declaration
+  if (n.type === 'FunctionDeclaration' && n.body) {
+    const sig = src.slice(n.start, n.body.start)
+    const units = n.body.body.map((s, i) => ({ key: keyOf(s, i), text: src.slice(s.start, s.end) }))
+    return { sig, units, open: '{\n  ', join: '\n  ', close: '\n}' }
+  }
+  if (n.type === 'ClassDeclaration' && n.body) {
+    const sig = src.slice(n.start, n.body.start)
+    const units = n.body.body.map((m, i) => ({ key: memberKey(m, i), text: src.slice(m.start, m.end) }))
+    return { sig, units, open: '{\n  ', join: '\n\n  ', close: '\n}' }
+  }
+  // `const x = { ... }` / `const x = () => { ... }` / `const x = function () { ... }`
+  if (n.type === 'VariableDeclaration' && n.declarations.length === 1 && n.declarations[0].init) {
+    const init = n.declarations[0].init
+    if (init.type === 'ObjectExpression') {
+      const sig = src.slice(n.start, init.start)
+      const units = init.properties.map((p, i) => ({ key: propKey(p, i), text: src.slice(p.start, p.end) }))
+      return { sig, units, open: '{\n  ', join: ',\n  ', close: '\n}' }
+    }
+    if ((init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression') && init.body && init.body.type === 'BlockStatement') {
+      const sig = src.slice(n.start, init.body.start)
+      const units = init.body.body.map((s, i) => ({ key: keyOf(s, i), text: src.slice(s.start, s.end) }))
+      return { sig, units, open: '{\n  ', join: '\n  ', close: '\n}' }
+    }
+  }
+  return null
+}
+
+// Stable key for an object-literal property, so two agents adding DIFFERENT keys union.
+function propKey(p, i) {
+  if (p.type === 'SpreadElement') return 'spread:' + i
+  if (p.key && p.key.type === 'Identifier' && !p.computed) return 'prop:' + p.key.name
+  if (p.key && p.key.type === 'Literal') return 'prop:' + String(p.key.value)
+  return 'prop:' + i
+}
+
+// Does `src` parse either as top-level code OR as a class member? (The inner-merge result
+// for a method is a fragment that's only valid inside a class — this lets us validate it.)
+function parsesUnit(src) {
+  if (parses(src)) return true
+  try { parse(MEMBER_WRAP + src + '}'); return true } catch { return false }
+}
+
+// The provider contract every ICR language module implements.
+export const javascript = {
+  id: 'javascript',
+  exts: ['.js', '.mjs', '.cjs'],
+  parses,
+  units,
+  declaredNames,
+  usedIdentifiers,      // approximate (kept for reference)
+  referencedFreeNames,  // scope-aware — what the engine prefers for the dangling check
+  declBody,
+  renameRefs,           // rewrites every matching identifier (kept for reference)
+  renameFreeRefs,       // scope-aware — only rewrites references that resolve to the binding
+  splitUnit,            // finer granularity: split a function/class/method into keyed inner units
+  parsesUnit,           // validity oracle that also accepts a class-member fragment
+  mergeUnit,            // language-specific same-key merge (import specifier union)
+}

package/lang-python.js

@@ -0,0 +1,149 @@
+// Python language provider for ICR — indentation-based structural splitter.
+// Implements the ICR provider contract { id, exts, parses, units, declaredNames,
+// splitUnit, parsesUnit } so the shared merge engine merges Python by structure:
+// top-level defs/classes/statements are units keyed by name; editing different
+// methods of the same class merges via splitUnit. Heuristic (tracks #-comments,
+// triple-quoted and normal strings, bracket depth) — not a full parser; parses()
+// is an approximate balanced-delimiter check.
+
+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 (src[j] === '\\') { j += 2; continue } if (src[j] === q) { j++; break } if (src[j] === '\n') break; j++ } return j }
+    return -1
+  }
+}
+
+// Line records: { start, end (incl newline), indent, blank, text }
+function lines(src) {
+  const out = []
+  let i = 0
+  while (i < src.length) {
+    let e = src.indexOf('\n', i); if (e < 0) e = src.length; else e = e + 1
+    const raw = src.slice(i, e)
+    const trimmed = raw.replace(/\r?\n$/, '')
+    let indent = 0; while (indent < trimmed.length && (trimmed[indent] === ' ' || trimmed[indent] === '\t')) indent++
+    const blank = trimmed.trim() === '' || trimmed.trim().startsWith('#')
+    out.push({ start: i, end: e, indent, blank, text: raw })
+    i = e
+  }
+  return out
+}
+
+const HEAD = /^\s*(?:async\s+def|def)\s+([A-Za-z_]\w*)/
+const CLS = /^\s*class\s+([A-Za-z_]\w*)/
+
+function keyOf(text) {
+  let m = text.match(HEAD); if (m) return 'def:' + m[1]
+  m = text.match(CLS); if (m) return 'class:' + m[1]
+  return 'stmt:' + text.split('\n')[0].trim().replace(/\s+/g, ' ')
+}
+
+// Split src into units whose heads sit at exactly `base` indentation. A def/class
+// head owns the following blank + more-indented lines (its body). A run of leading
+// @decorator lines attaches to the head that follows. Everything else is a
+// one-logical-line statement (continued while bracket depth > 0).
+function blocks(src, base = 0) {
+  const L = lines(src)
+  const at = scannerAt(src)
+  const units = []
+  let i = 0
+  // find bracket depth over a line range (to keep continued statements together)
+  const bracketDelta = (s, e) => {
+    let d = 0, k = s
+    while (k < e) { const j = at(k); if (j > k) { k = j; continue } const c = src[k]; if (c === '(' || c === '[' || c === '{') d++; else if (c === ')' || c === ']' || c === '}') d--; k++ }
+    return d
+  }
+  while (i < L.length) {
+    while (i < L.length && L[i].blank) i++            // skip blank/comment gap lines
+    if (i >= L.length) break
+    if (L[i].indent !== base) { // stray deeper line (shouldn't happen at top) — treat as its own stmt
+      const s = L[i].start; let e = L[i].end; i++
+      units.push({ start: s, end: e })
+      continue
+    }
+    const start = L[i].start
+    // consume leading decorators
+    let isDecorator = /^\s*@/.test(L[i].text)
+    while (i < L.length && L[i].indent === base && /^\s*@/.test(L[i].text)) i++
+    const headIdx = i
+    const head = i < L.length ? L[i] : null
+    if (head && (HEAD.test(head.text) || CLS.test(head.text) || isDecorator)) {
+      // a block: consume the header line, then its body (blank or deeper-indented lines)
+      i++ // header line
+      while (i < L.length && (L[i].blank || L[i].indent > base)) i++
+      units.push({ start, end: L[i - 1].end })
+    } else if (head) {
+      // simple statement: consume continued lines while bracket depth remains open
+      let e = head.end, depth = bracketDelta(head.start, head.end); i++
+      while (i < L.length && (depth > 0 || /\\\s*$/.test(L[i - 1].text.replace(/\r?\n$/, '')))) { depth += bracketDelta(L[i].start, L[i].end); e = L[i].end; i++ }
+      units.push({ start, end: e })
+    }
+  }
+  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
+}
+
+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
+}
+
+export const python = {
+  id: 'python',
+  exts: ['.py', '.pyi'],
+  parses: (src) => balanced(String(src == null ? '' : src)),
+  parsesUnit: (src) => balanced(String(src)),
+  units: (src) => keyed(blocks(String(src), 0), String(src)),
+  declaredNames: (src) => {
+    const names = new Set()
+    for (const u of keyed(blocks(String(src), 0), String(src))) {
+      const m = u.key.match(/^(?:def|class):([A-Za-z_]\w*)/)
+      if (m) names.add(m[1])
+    }
+    return names
+  },
+  // Descend into a class/def body so two agents editing DIFFERENT methods merge.
+  splitUnit: (text) => {
+    const src = String(text)
+    const L = lines(src)
+    let h = 0; while (h < L.length && (L[h].blank || /^\s*@/.test(L[h].text))) h++
+    if (h >= L.length) return null
+    // Only descend into a CLASS (named methods → mergeable). A def body is bare
+    // statements with no stable keys; descending would falsely merge two edits to the
+    // same function, so we don't — same-def edits become a clean conflict instead.
+    if (!CLS.test(L[h].text)) return null
+    const headEnd = L[h].end
+    // body = everything after the header line; its base indent is the first body line's indent
+    let b = h + 1; while (b < L.length && L[b].blank) b++
+    if (b >= L.length) return null
+    const bodyIndent = L[b].indent
+    const sig = src.slice(0, headEnd)
+    const body = src.slice(headEnd)
+    const inner = keyed(blocks(body, bodyIndent), body)
+    return { sig, open: '', close: '', body, units: inner, join: '' }
+  },
+}

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "hivecode-mcp",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "MCP server that lets any AI coding agent join a Hivecode room — humans and multiple AI agents edit one live codebase with folder-scoped permissions and approval gates.",
   "type": "module",
   "license": "MIT",
-  "homepage": "https://github.com/GSK7024/livecode",
+  "homepage": "https://github.com/Ganesh-Kute/HiveCode",
   "bugs": {
-    "url": "https://github.com/GSK7024/livecode/issues"
+    "url": "https://github.com/Ganesh-Kute/HiveCode/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/GSK7024/livecode"
+    "url": "https://github.com/Ganesh-Kute/HiveCode"
   },
   "keywords": [
     "mcp",
@@ -30,6 +30,13 @@
     "sync.js",
     "core.js",
     "token.js",
+    "icr.js",
+    "lang-js.js",
+    "lang-brace.js",
+    "lang-python.js",
+    "icr-merge.js",
+    "hive-coord.js",
+    "substrate.js",
     "HIVE_RULES.md",
     "MCP.md",
     "README.md",
@@ -41,7 +48,12 @@
   "scripts": {
     "start": "node server.js",
     "relay": "node server.js",
-    "test": "node test.js"
+    "test": "node test.js",
+    "test:substrate": "node substrate-test.js",
+    "test:substrate:live": "node substrate-live-test.js",
+    "test:substrate:enforce": "node substrate-enforce-test.js",
+    "test:substrate:authority": "node substrate-authority-test.js",
+    "test:substrate:all": "node substrate-test.js && node substrate-live-test.js && node substrate-enforce-test.js && node substrate-authority-test.js"
   },
   "engines": {
     "node": ">=18"
@@ -49,6 +61,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.104.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "acorn": "^8.17.0",
     "ignore": "^7.0.5",
     "ws": "^8.18.0",
     "y-websocket": "^2.0.4",