hivecode-mcp 0.7.0 → 0.11.0

package/README.md

@@ -7,10 +7,8 @@ live, **fence** each agent to the folders it's allowed in, **approve** the risky
 moves, and **undo** any agent instantly. No git push/pull. Open source.
 
 [**Install for VS Code**](https://marketplace.visualstudio.com/items?itemName=hivecode.hivecode)
-· [**Website**](https://livecode-xoss.onrender.com)
-· [Latest .vsix](https://github.com/GSK7024/livecode/releases)
-
-<!-- Add a demo GIF here once recorded: ![demo](docs/demo.gif) -->
+· [**Website**](https://hivecode.vercel.app)
+· [Latest .vsix](https://github.com/Ganesh-Kute/HiveCode/releases)
 
 ---
 
@@ -34,97 +32,57 @@ git push/pull — edits sync in about a second.
 
 ---
 
-## Quickstart
-
-1. Install the extension (link above). It works in **VS Code, Cursor, Windsurf,
-   and Antigravity**.
-2. Open the folder you want to share (**File → Open Folder**).
-3. `Ctrl/Cmd+Shift+P` → **Hivecode: Host a Secured Session**. A join link is
-   copied to your clipboard. *(No terminal, no server to run.)*
-4. **Hivecode: Invite to folders…** → pick the folders and a role (edit /
-   read-only) for each person or agent. Send them the link.
-5. They run **Hivecode: Join a Session** and paste the link. You're now editing
-   the same project live.
+## Proof
 
-Use **Manage access** to re-scope or revoke anyone, and **Leave Session** to stop.
+The hard part is what happens when two agents edit the same file. Git compares lines, so
+a rename on one side and a new call site on the other merge with no conflict — and ship a
+crash. **ICR**, our merge engine, compares structure and intent instead.
 
----
+Measured on [CooperBench](https://arxiv.org/abs/2601.13295) (Stanford, 2026), which gives
+two agents independent features on one repo and scores the result by running **both**
+features' own test suites. Of its 652 gold pairs — professional human patches, the
+cleanest possible input — **505 conflict under git**:
 
-## Add an AI agent
+| Merge layer | Of those 505, integrated cleanly | Passes both test suites |
+|---|---|---|
+| `git merge` | 0 (0%) | — |
+| mergiraf 0.18 | 56 (11.1%) | — |
+| **ICR** — safe default | **112 (22.2%)** | **100%** (27/27) |
+| **ICR** — union mode | **206 (40.8%)** | **96.2%** (50/52) |
 
-Agents join through the Hivecode MCP server ([`hive-mcp.js`](hive-mcp.js)). Set it
-up once, then just hand the agent a join link; it appears in the room as an `ai`
-member, scoped to exactly the folders you invited it to.
+Three more independent checks:
 
-- **[JOIN_WITH_AGENT.md](JOIN_WITH_AGENT.md)** — step-by-step for a *human*: set up MCP, then bring your agent in.
-- **[AGENT_MANUAL.md](AGENT_MANUAL.md)** — written *for the agent*: how to set itself up and join (drop it in your project as `CLAUDE.md` so the agent reads it automatically).
-- **[MCP.md](MCP.md)** — the full tool reference.
+- **279 real conflicts humans already resolved** — compared against what the maintainer
+  actually committed: ICR matched 87, mergiraf 64, zero broken outputs, ICR ahead on all
+  five repositories.
+- **[ConGra](https://arxiv.org/abs/2409.14121), 6,430 real Python conflicts** verified with
+  CPython's own `ast.parse`: 32.1% resolved vs mergiraf's 31.8%, with **zero crashes and
+  zero parse-guarantee violations**.
+- **Properties, not examples** — symmetry (`M(b,x,y) = M(b,y,x)`), fixed-point, no-loss and
+  the parse guarantee, under seeded fuzz across 20+ languages: 13,000+ assertions, green.
 
----
+Reproduce any of it: the harnesses are in [`scripts/`](scripts/) and the raw receipts in
+[`data/`](data/).
 
-## What you get
-
-**Oversight & control** *(the point of the whole thing)*
-- **Live Control Room** — watch every agent and every file it touches in real time,
-  from any browser or your phone. No more "what is it even doing right now?"
-- **Folder-scoped access** — invite an agent to `frontend/` only; it never receives
-  anything else (relay-enforced, not trust-based).
-- **Approval gates** — risky work waits for your OK; agent-to-agent coordination
-  flows automatically.
-- **Instant rollback** — restore any file to an earlier point, or **revert
-  *everything* one agent did** in a click. Undo a rogue agent without touching the
-  rest of the team's work.
-- **Mission control** — pause, resume, or reassign any agent; agents honor it
-  mid-task.
-- **Instant revoke** — cut access mid-session, enforced server-side on every
-  reconnect (and it survives a relay restart).
-- **Read-only roles** — reviewers see everything, change nothing.
-
-**Coordination**
-- **Built-in chat**, a **shared task board** (assign / complete), and **live
-  presence** so humans and agents stay in sync.
-- **Co-editing heads-up** before two people touch the same file.
-- **Never lose work** — overlapping edits keep both versions with conflict markers;
-  a stale rewrite can't silently delete another's lines.
-
-**Trust**
-- **Server-enforced auth** — signed tokens, algorithm-pinned, fail-closed.
-  Unauthorized clients never complete the WebSocket handshake.
-- **Self-certifying secured rooms** — the room id embeds a fingerprint of your
-  public key; tokens carry the key and are signed by it; the relay trusts a token
-  only if the fingerprint matches. No account system, no shared secret. Your
-  private key stays in the editor's secure storage.
-- **Dependency-free core** — the access-control layer uses only Node's `crypto`.
+```bash
+npx git-clash                                      # see it on three real collision scenarios
+npx git-clash --scan --base=main --head=my-branch  # check one of YOUR merges before you make it
+npm i icr-merge         # the engine: library, CLI, and git merge driver (MIT)
+npx hivecode-mcp        # the live medium, as MCP tools for any agent
+```
 
 ---
 
-## How the security model works
-
-A secured room's id is `hs_<fp>_<rand>`, where `fp` is a base64url SHA-256
-fingerprint of the owner's public key. Every token for the room carries the owner's
-public key (claim `pk`) and is signed by the matching private key (RS256). The relay
-trusts a token **iff** `fingerprint(token.pk) === fingerprint-in-room-id`, then
-verifies the signature with that key — so trust is anchored in the room id itself
-and the relay stores nothing.
-
-Files use a per-file subdocument model: the room is `<base>`, each file is a
-separate document at `<base>␁<path>`. The relay authorizes per path, so a scoped
-client can only open the files it may load, and out-of-scope content never reaches
-its disk. Paths are guarded against traversal, absolute paths, drive letters, and
-control characters on both the client (before writing) and the relay.
+## Documentation
 
-A full threat/edge-case audit is in [EDGE-CASES.md](EDGE-CASES.md); the RBAC design
-is in [RBAC.md](RBAC.md).
+To keep this README clean, we've modularized the documentation into separate files. Click below to read more about each specific topic:
 
----
-
-## Self-hosting the relay
-
-The hosted relay is the default (`wss://livecode-xoss.onrender.com`) and needs no
-setup. To run your own, deploy [`server.js`](server.js) anywhere Node runs and set
-`hivecode.relayUrl` in the extension. The relay holds no truth of its own — it just
-passes CRDT updates between clients in the same room, and enforces access at the
-handshake. See [DEPLOY.md](DEPLOY.md).
+- **[🔌 Connecting & Hosting Rooms](docs/CONNECTING_ROOMS.md)** - Learn how humans join rooms, how to host your own relay server, and how the self-certifying security model works.
+- **[🤖 AI Agent Manual](docs/AI_AGENT_MANUAL.md)** - A guide written specifically for AI agents on how to download the MCP server, join a room, and behave within the hive.
+- **[🏛️ Hivecode Explained, end to end](HIVECODE_EXPLAINED.md)** - The full course: every mechanism motivated, explained, and shown with worked examples and runnable code — CRDT internals, the ICR pipeline, provenance, the benchmarks.
+- **[🧠 ICR (Intent-aware Code Replication)](docs/ICR_EXPLAINED.md)** - How our semantic AST-aware merge algorithm guarantees no lines are lost during multi-agent collisions.
+- **[🔐 DCO (Deterministic Context Override)](docs/DCO_EXPLAINED.md)** - The core breakthrough paradigm that physically locks tools based on CRDT state, structurally preventing agent hallucination and drift. Includes our End-to-End Test Report.
+- **[🔗 The Substrate](docs/SUBSTRATE.md)** - A governed *medium* (not a channel) for multi-agent code: every change is a signed `(intent, patch, provenance)` triple, and the medium guarantees it converges, never regresses, and is provenance-verified — enforced by the relay, with no controller. Runnable + testable in one command.
 
 ---
 
@@ -132,8 +90,10 @@ handshake. See [DEPLOY.md](DEPLOY.md).
 
 ```bash
 npm install
-node test.js          # unit tests
+node tests/test.js     # unit tests
 node hive-edge-test.js # adversarial / edge-case live tests
+
+npm run test:substrate:all   # the substrate: 4 suites (core + live + enforcement + content authority)
 ```
 
 Other live suites: `hive-secure-test.js`, `hive-scope-test.js`, `hive-auth-test.js`,
@@ -144,6 +104,13 @@ The extension source is in [`extension/`](extension/).
 
 ---
 
+## Support
+
+- **Issues** — https://github.com/Ganesh-Kute/HiveCode/issues
+- **Email** — support@getgrm.tech
+
+---
+
 ## License
 
 MIT.

package/core.js

@@ -89,18 +89,77 @@ export function mergeEdit(base, mine, current) {
   return { conflict: true } // same lines changed two ways -> re-reason on `current`
 }
 
+// Detect REAL git-style conflict markers in a file. Line-anchored on purpose:
+// it requires an opening `<<<<<<< ` AND a closing `>>>>>>> ` each at the start
+// of a line. This is what merge3 emits. A naive `text.includes('<<<<<<<')`
+// false-positives on any file that merely MENTIONS the markers (e.g. a README
+// documenting conflict resolution), which would announce a phantom conflict on
+// every sync. (Found by a live two-agent test, 2026-06-19.)
+export function hasConflictMarkers(text) {
+  return /^<<<<<<< /m.test(text || '') && /^>>>>>>> /m.test(text || '')
+}
+
+// Strip and de-nest conflict markers to prevent exponential 2^N code ballooning
+export function stripConflictMarkers(text, prefer = 'local') {
+  if (!text || !hasConflictMarkers(text)) return text || ''
+  const lines = text.split('\n')
+  const out = []
+  let inConflict = false
+  let inTheirs = false
+  const localBlock = []
+  const theirsBlock = []
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (/^<<<<<<< /.test(line)) {
+      inConflict = true
+      inTheirs = false
+      localBlock.length = 0
+      theirsBlock.length = 0
+      continue
+    }
+    if (/^=======$/.test(line) && inConflict) {
+      inTheirs = true
+      continue
+    }
+    if (/^>>>>>>> /.test(line) && inConflict) {
+      inConflict = false
+      out.push(...(prefer === 'theirs' ? theirsBlock : localBlock))
+      continue
+    }
+    if (inConflict) {
+      if (inTheirs) theirsBlock.push(line)
+      else localBlock.push(line)
+    } else {
+      out.push(line)
+    }
+  }
+  return out.join('\n')
+}
+
 // --- 3-way merge for the SYNC layer (disk <-> shared doc) ---
 // Same idea as mergeEdit, but instead of bailing with { conflict } it always
 // returns text: disjoint edits merge cleanly; overlapping edits are wrapped in
 // git-style conflict markers so BOTH versions survive and a human/AI resolves.
+// De-nests existing conflict blocks to prevent exponential duplication.
 //   merge3(base, mine, theirs) -> { text, conflict }
 export function merge3(base, mine, theirs) {
   if (mine === theirs) return { text: mine, conflict: false }
   if (base === theirs) return { text: mine, conflict: false }  // only I changed
   if (base === mine) return { text: theirs, conflict: false }  // only they changed
-  const b = base.split('\n')
-  const mr = changedRange(b, mine.split('\n'))
-  const tr = changedRange(b, theirs.split('\n'))
+
+  // De-nest stale conflict markers so conflict blocks never wrap exponentially
+  const cleanBase = hasConflictMarkers(base) ? stripConflictMarkers(base, 'local') : (base || '')
+  const cleanMine = hasConflictMarkers(mine) ? stripConflictMarkers(mine, 'local') : (mine || '')
+  const cleanTheirs = hasConflictMarkers(theirs) ? stripConflictMarkers(theirs, 'theirs') : (theirs || '')
+
+  if (cleanMine === cleanTheirs) return { text: cleanMine, conflict: false }
+  if (cleanBase === cleanTheirs) return { text: cleanMine, conflict: false }
+  if (cleanBase === cleanMine) return { text: cleanTheirs, conflict: false }
+
+  const b = cleanBase.split('\n')
+  const mr = changedRange(b, cleanMine.split('\n'))
+  const tr = changedRange(b, cleanTheirs.split('\n'))
   if (mr.endBase <= tr.startBase || tr.endBase <= mr.startBase) {
     const out = b.slice()
     for (const e of [mr, tr].sort((x, y) => y.startBase - x.startBase)) {
@@ -125,16 +184,6 @@ export function merge3(base, mine, theirs) {
   return { text: out.join('\n'), conflict: true }
 }
 
-// Detect REAL git-style conflict markers in a file. Line-anchored on purpose:
-// it requires an opening `<<<<<<< ` AND a closing `>>>>>>> ` each at the start
-// of a line. This is what merge3 emits. A naive `text.includes('<<<<<<<')`
-// false-positives on any file that merely MENTIONS the markers (e.g. a README
-// documenting conflict resolution), which would announce a phantom conflict on
-// every sync. (Found by a live two-agent test, 2026-06-19.)
-export function hasConflictMarkers(text) {
-  return /^<<<<<<< /m.test(text) && /^>>>>>>> /m.test(text)
-}
-
 // --- Rewrite detection for the auto-board ---
 // Classify a change as a small PATCH (grep-and-edit, the common case) vs a
 // wholesale REWRITE, and pull out the symbol names the new version defines in