@sym-bot/sym 0.1.0

package/lib/node.js

@@ -0,0 +1,507 @@
+'use strict';
+
+const net = require('net');
+const crypto = require('crypto');
+const path = require('path');
+const { EventEmitter } = require('events');
+const { MeshNode } = require('mesh-cognition');
+const { nodeDir, loadOrCreateIdentity, ensureDir, log: logMsg } = require('./config');
+const { MemoryStore } = require('./memory-store');
+const { FrameParser, sendFrame } = require('./frame-parser');
+const { encode, DIM } = require('./context-encoder');
+
+/**
+ * SymNode — a sovereign mesh node with cognitive coupling.
+ *
+ * Each node encodes its memories into a hidden state vector.
+ * When peers connect, the coupling engine evaluates drift between
+ * their cognitive states and autonomously decides whether to couple.
+ *
+ * Aligned peers share memories. Divergent peers stay independent.
+ * The intelligence is in the decision to share, not in the sharing itself.
+ */
+class SymNode extends EventEmitter {
+
+  constructor(opts = {}) {
+    super();
+    if (!opts.name) throw new Error('SymNode requires a name');
+    this._silent = opts.silent || false;
+
+    this.name = opts.name;
+    this._cognitiveProfile = opts.cognitiveProfile || null;
+    this._moodThreshold = opts.moodThreshold ?? 0.8;
+    this._identity = loadOrCreateIdentity(this.name);
+    this._dir = nodeDir(this.name);
+    this._memoriesDir = path.join(this._dir, 'memories');
+    this._store = new MemoryStore(this._memoriesDir, this.name);
+
+    // Coupling engine — evaluates peer cognitive state
+    this._meshNode = new MeshNode({ hiddenDim: DIM });
+    this._initLocalState();
+
+    // Peer state
+    this._peers = new Map();
+    this._server = null;
+    this._bonjour = null;
+    this._browser = null;
+    this._port = 0;
+    this._running = false;
+
+    // Timers
+    this._heartbeatInterval = opts.heartbeatInterval || 5000;
+    this._heartbeatTimeout = opts.heartbeatTimeout || 15000;
+    this._heartbeatTimer = null;
+    this._encodeInterval = opts.encodeInterval || 30000;
+    this._encodeTimer = null;
+  }
+
+  // ── Context Encoding ───────────────────────────────────────
+
+  _initLocalState() {
+    const context = this._buildContext();
+    if (context.length > 5) {
+      const { h1, h2 } = encode(context);
+      this._meshNode.updateLocalState(h1, h2, 0.8);
+    } else {
+      const h1 = Array.from({ length: DIM }, () => (Math.random() - 0.5) * 0.1);
+      const h2 = Array.from({ length: DIM }, () => (Math.random() - 0.5) * 0.1);
+      this._meshNode.updateLocalState(h1, h2, 0.3);
+    }
+  }
+
+  _buildContext() {
+    const parts = [];
+    if (this._cognitiveProfile) parts.push(this._cognitiveProfile);
+    const entries = this._store.allEntries().slice(0, 20);
+    parts.push(...entries.map(e => e.content || ''));
+    return parts.join('\n');
+  }
+
+  _reencodeAndBroadcast() {
+    const context = this._buildContext();
+    if (context.length < 5) return;
+
+    const { h1, h2 } = encode(context);
+    this._meshNode.updateLocalState(h1, h2, 0.8);
+
+    // Broadcast cognitive state to all peers for re-evaluation
+    this._broadcastToPeers({ type: 'state-sync', h1, h2, confidence: 0.8 });
+  }
+
+  /**
+   * Update cognitive state from external context (e.g. Claude Code's memories).
+   * Does not store anything — just re-encodes and broadcasts.
+   */
+  updateContext(text) {
+    if (!text || text.length < 5) return;
+    const { h1, h2 } = encode(text);
+    this._meshNode.updateLocalState(h1, h2, 0.8);
+    this._broadcastToPeers({ type: 'state-sync', h1, h2, confidence: 0.8 });
+  }
+
+  /**
+   * Share content with cognitively aligned peers without storing locally.
+   * Used by ClaudeMemoryBridge — Claude Code's memory dir is the source of truth.
+   */
+  shareWithPeers(content, opts = {}) {
+    const entry = {
+      key: opts.key || `memory-${Date.now()}`,
+      content,
+      source: opts.source || this.name,
+      tags: opts.tags || [],
+      timestamp: Date.now(),
+    };
+
+    this._meshNode.coupledState();
+    const decisions = this._meshNode.couplingDecisions;
+
+    let shared = 0;
+    for (const [peerId, peer] of this._peers) {
+      const d = decisions.get(peerId);
+      if (d && d.decision === 'rejected') {
+        this._log(`Not sharing with ${peer.name} — rejected (drift: ${d.drift.toFixed(3)})`);
+        continue;
+      }
+      sendFrame(peer.socket, { type: 'memory-share', ...entry });
+      shared++;
+      if (d) {
+        this._log(`Shared with ${peer.name} — ${d.decision} (drift: ${d.drift.toFixed(3)})`);
+      }
+    }
+
+    this._log(`Shared: "${content.slice(0, 50)}${content.length > 50 ? '...' : ''}" → ${shared}/${this._peers.size} peers`);
+    return entry;
+  }
+
+  // ── Lifecycle ──────────────────────────────────────────────
+
+  async start() {
+    if (this._running) return;
+    this._running = true;
+
+    await this._startServer();
+    this._startDiscovery();
+
+    this._heartbeatTimer = setInterval(() => this._checkHeartbeats(), this._heartbeatInterval);
+    this._encodeTimer = setInterval(() => this._reencodeAndBroadcast(), this._encodeInterval);
+
+    this._log(`Started (port: ${this._port}, id: ${this._identity.nodeId.slice(0, 8)})`);
+  }
+
+  async stop() {
+    if (!this._running) return;
+    this._running = false;
+
+    if (this._heartbeatTimer) clearInterval(this._heartbeatTimer);
+    if (this._encodeTimer) clearInterval(this._encodeTimer);
+
+    for (const [, peer] of this._peers) {
+      try { peer.socket.destroy(); } catch {}
+    }
+    this._peers.clear();
+
+    if (this._bonjour) {
+      try { this._bonjour.destroy(); } catch {}
+      this._bonjour = null;
+    }
+
+    if (this._server) {
+      this._server.close();
+      this._server = null;
+    }
+
+    this._log('Stopped');
+  }
+
+  // ── Memory (with cognitive coupling) ───────────────────────
+
+  remember(content, opts = {}) {
+    const entry = this._store.write(content, opts);
+
+    // Re-encode context with new memory
+    const context = this._buildContext();
+    const { h1, h2 } = encode(context);
+    this._meshNode.updateLocalState(h1, h2, 0.8);
+
+    // Evaluate coupling with each peer — only share with aligned/guarded
+    // Trigger coupling evaluation
+    this._meshNode.coupledState();
+    const decisions = this._meshNode.couplingDecisions;
+
+    let shared = 0;
+    for (const [peerId, peer] of this._peers) {
+      const d = decisions.get(peerId);
+
+      if (d && d.decision === 'rejected') {
+        this._log(`Not sharing with ${peer.name} — rejected (drift: ${d.drift.toFixed(3)})`);
+        continue;
+      }
+
+      sendFrame(peer.socket, { type: 'memory-share', ...entry });
+      shared++;
+
+      if (d) {
+        this._log(`Shared with ${peer.name} — ${d.decision} (drift: ${d.drift.toFixed(3)})`);
+      }
+    }
+
+    this._log(`Remembered: "${content.slice(0, 50)}${content.length > 50 ? '...' : ''}" → ${shared}/${this._peers.size} peers`);
+    return entry;
+  }
+
+  recall(query) {
+    return this._store.search(query);
+  }
+
+  // ── Mood (with cognitive evaluation) ───────────────────────
+
+  /**
+   * Broadcast mood to the mesh. Receiving agents evaluate this
+   * against their own cognitive state and autonomously decide
+   * whether to act. No routing. No registration. The coupling
+   * engine decides.
+   */
+  broadcastMood(mood, opts = {}) {
+    const frame = {
+      type: 'mood',
+      from: this._identity.nodeId,
+      fromName: this.name,
+      mood,
+      context: opts.context || null,
+      timestamp: Date.now(),
+    };
+    this._broadcastToPeers(frame);
+    this._log(`Mood broadcast: "${mood.slice(0, 50)}"`);
+  }
+
+  // ── Communication ──────────────────────────────────────────
+
+  send(message, opts = {}) {
+    const frame = {
+      type: 'message',
+      from: this._identity.nodeId,
+      fromName: this.name,
+      content: message,
+      timestamp: Date.now(),
+    };
+    if (opts.to) {
+      const peer = this._peers.get(opts.to);
+      if (peer) sendFrame(peer.socket, frame);
+    } else {
+      this._broadcastToPeers(frame);
+    }
+  }
+
+  // ── Monitoring ─────────────────────────────────────────────
+
+  peers() {
+    const result = [];
+    const decisions = this._meshNode.couplingDecisions;
+    for (const [id, peer] of this._peers) {
+      const d = decisions.get(id);
+      result.push({
+        id: id.slice(0, 8),
+        name: peer.name || 'unknown',
+        connected: true,
+        lastSeen: peer.lastSeen,
+        coupling: d ? d.decision : 'pending',
+        drift: d ? parseFloat(d.drift.toFixed(3)) : null,
+      });
+    }
+    return result;
+  }
+
+  memories() {
+    return this._store.count();
+  }
+
+  coherence() {
+    return this._meshNode.coherence;
+  }
+
+  status() {
+    return {
+      name: this.name,
+      nodeId: this._identity.nodeId.slice(0, 8),
+      running: this._running,
+      port: this._port,
+      peers: this.peers(),
+      peerCount: this._peers.size,
+      memoryCount: this.memories(),
+      coherence: this.coherence(),
+    };
+  }
+
+  // ── TCP Server ─────────────────────────────────────────────
+
+  _startServer() {
+    return new Promise((resolve, reject) => {
+      this._server = net.createServer((socket) => {
+        this._handleInboundConnection(socket);
+      });
+      this._server.on('error', (err) => {
+        this._log(`Server error: ${err.message}`);
+        reject(err);
+      });
+      this._server.listen(0, '0.0.0.0', () => {
+        this._port = this._server.address().port;
+        resolve();
+      });
+    });
+  }
+
+  _handleInboundConnection(socket) {
+    const parser = new FrameParser();
+    let identified = false;
+    const timeout = setTimeout(() => { if (!identified) socket.destroy(); }, 10000);
+
+    socket.on('data', (chunk) => { if (!identified) parser.feed(chunk); });
+
+    parser.on('message', (msg) => {
+      if (identified) return;
+      if (msg.type !== 'handshake') { socket.destroy(); return; }
+      identified = true;
+      clearTimeout(timeout);
+      if (this._peers.has(msg.nodeId)) { socket.destroy(); return; }
+      const peer = this._createPeer(socket, msg.nodeId, msg.name, false);
+      if (parser.buffer.length > 0) peer.parser.feed(parser.buffer);
+      this._addPeer(peer);
+    });
+
+    socket.on('error', () => clearTimeout(timeout));
+  }
+
+  // ── Bonjour Discovery ──────────────────────────────────────
+
+  _startDiscovery() {
+    const { Bonjour } = require('bonjour-service');
+    this._bonjour = new Bonjour();
+
+    this._bonjour.publish({
+      name: this._identity.nodeId,
+      type: 'sym',
+      port: this._port,
+      txt: { 'node-id': this._identity.nodeId, 'node-name': this.name, 'hostname': this._identity.hostname },
+    });
+
+    this._browser = this._bonjour.find({ type: 'sym' });
+
+    this._browser.on('up', (service) => {
+      const peerId = service.txt?.['node-id'];
+      if (!peerId || peerId === this._identity.nodeId) return;
+      const peerName = service.txt?.['node-name'] || 'unknown';
+      const address = service.referer?.address || service.addresses?.[0];
+      const port = service.port;
+      if (!address || !port) return;
+      if (this._identity.nodeId < peerId && !this._peers.has(peerId)) {
+        this._connectToPeer(address, port, peerId, peerName);
+      }
+    });
+  }
+
+  _connectToPeer(address, port, peerId, peerName) {
+    if (this._peers.has(peerId)) return;
+    const socket = net.createConnection({ host: address, port }, () => {
+      const peer = this._createPeer(socket, peerId, peerName, true);
+      this._addPeer(peer);
+    });
+    socket.on('error', (err) => this._log(`Connect failed to ${peerName}: ${err.message}`));
+    socket.setTimeout(10000, () => socket.destroy());
+  }
+
+  // ── Peer Management ────────────────────────────────────────
+
+  _createPeer(socket, peerId, peerName, isOutbound) {
+    const parser = new FrameParser();
+    socket.on('data', (chunk) => parser.feed(chunk));
+    parser.on('message', (msg) => {
+      const peer = this._peers.get(peerId);
+      if (peer) peer.lastSeen = Date.now();
+      this._handlePeerMessage(peerId, peerName, msg);
+    });
+    parser.on('error', (err) => this._log(`Frame error from ${peerName}: ${err.message}`));
+    socket.on('close', () => {
+      this._peers.delete(peerId);
+      this._meshNode.removePeer(peerId);
+      this._log(`Peer disconnected: ${peerName}`);
+      this.emit('peer-left', { id: peerId, name: peerName });
+    });
+    socket.on('error', () => {});
+    return { socket, parser, peerId, name: peerName, isOutbound, lastSeen: Date.now() };
+  }
+
+  _addPeer(peer) {
+    this._peers.set(peer.peerId, peer);
+
+    // Handshake
+    sendFrame(peer.socket, { type: 'handshake', nodeId: this._identity.nodeId, name: this.name });
+
+    // Send cognitive state for coupling evaluation
+    const [h1, h2] = this._meshNode.coupledState();
+    sendFrame(peer.socket, { type: 'state-sync', h1, h2, confidence: 0.8 });
+
+    this._log(`Peer connected: ${peer.name} (${peer.isOutbound ? 'outbound' : 'inbound'})`);
+    this.emit('peer-joined', { id: peer.peerId, name: peer.name });
+  }
+
+  _handlePeerMessage(peerId, peerName, msg) {
+    switch (msg.type) {
+      case 'handshake':
+        break;
+
+      case 'state-sync':
+        // Peer sent their cognitive state — evaluate coupling
+        if (msg.h1?.length === DIM && msg.h2?.length === DIM) {
+          this._meshNode.addPeer(peerId, msg.h1, msg.h2, msg.confidence || 0.5);
+          this._meshNode.coupledState(); // trigger evaluation
+          const d = this._meshNode.couplingDecisions.get(peerId);
+          if (d) {
+            this._log(`Coupling with ${peerName}: ${d.decision} (drift: ${d.drift.toFixed(3)})`);
+            this.emit('coupling-decision', { peer: peerName, decision: d.decision, drift: d.drift });
+          }
+        }
+        break;
+
+      case 'memory-share':
+        if (msg.content) {
+          // Check coupling before accepting
+          const d = this._meshNode.couplingDecisions.get(peerId);
+          if (d && d.decision === 'rejected') {
+            this._log(`Rejected memory from ${peerName} (drift: ${d.drift.toFixed(3)})`);
+            break;
+          }
+          this._store.receiveFromPeer(peerId, msg);
+          this._log(`Memory from ${peerName}: "${(msg.content || '').slice(0, 40)}..." [${d?.decision || 'accepted'}]`);
+          this.emit('memory-received', { from: peerName, entry: msg, decision: d?.decision });
+        }
+        break;
+
+      case 'mood':
+        // Peer broadcast their mood. Use the SDK's coupling engine to evaluate
+        // whether this mood is relevant to our cognitive state.
+        if (msg.mood) {
+          const { h1: moodH1, h2: moodH2 } = encode(msg.mood);
+          const moodPeerId = `mood-${peerId}`;
+
+          // Evaluate mood using the SDK's coupling engine
+          this._meshNode.addPeer(moodPeerId, moodH1, moodH2, 0.8);
+          this._meshNode.coupledState();
+          const d = this._meshNode.couplingDecisions.get(moodPeerId);
+          this._meshNode.removePeer(moodPeerId);
+
+          const from = msg.fromName || peerName;
+          const drift = d ? d.drift : 1;
+
+          // Mood uses the agent's moodThreshold (default 0.8) — more permissive
+          // than memory sharing (0.5). User wellbeing crosses domain boundaries.
+          if (drift <= this._moodThreshold) {
+            this._log(`Mood from ${from}: "${msg.mood.slice(0, 50)}" → ACCEPTED (drift: ${drift.toFixed(3)}, threshold: ${this._moodThreshold})`);
+            this.emit('mood-accepted', { from, mood: msg.mood, drift, context: msg.context });
+          } else {
+            this._log(`Mood from ${from}: "${msg.mood.slice(0, 50)}" → IGNORED (drift: ${drift.toFixed(3)}, threshold: ${this._moodThreshold})`);
+            this.emit('mood-rejected', { from, mood: msg.mood, drift });
+          }
+        }
+        break;
+
+      case 'message':
+        this._log(`Message from ${msg.fromName || peerName}: ${(msg.content || '').slice(0, 60)}`);
+        this.emit('message', msg.fromName || peerName, msg.content, msg);
+        break;
+
+      case 'ping':
+        const peer = this._peers.get(peerId);
+        if (peer) sendFrame(peer.socket, { type: 'pong' });
+        break;
+
+      case 'pong':
+        break;
+    }
+  }
+
+  _broadcastToPeers(frame) {
+    for (const [, peer] of this._peers) {
+      sendFrame(peer.socket, frame);
+    }
+  }
+
+  _checkHeartbeats() {
+    const now = Date.now();
+    for (const [id, peer] of this._peers) {
+      if (now - peer.lastSeen > this._heartbeatTimeout) {
+        this._log(`Heartbeat timeout: ${peer.name}`);
+        peer.socket.destroy();
+        this._peers.delete(id);
+        this._meshNode.removePeer(id);
+      } else if (now - peer.lastSeen > this._heartbeatInterval) {
+        sendFrame(peer.socket, { type: 'ping' });
+      }
+    }
+  }
+
+  _log(msg) {
+    if (!this._silent) logMsg(this.name, msg);
+  }
+}
+
+module.exports = { SymNode };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@sym-bot/sym",
+  "version": "0.1.0",
+  "description": "Local AI mesh — every agent is a sovereign node, the mesh is the agents",
+  "main": "lib/node.js",
+  "bin": {
+    "sym-mcp": "./integrations/claude-code/mcp-server.js"
+  },
+  "scripts": {
+    "test": "node --test tests/*.test.js"
+  },
+  "keywords": [
+    "mesh",
+    "p2p",
+    "collective-intelligence",
+    "ai-agents",
+    "mesh-cognition",
+    "mmp",
+    "peer-to-peer",
+    "local-ai",
+    "privacy"
+  ],
+  "author": "SYM.BOT Ltd <info@sym.bot> (https://sym.bot)",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/sym-bot/sym",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sym-bot/sym.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "bonjour-service": "^1.3.0",
+    "mesh-cognition": "^1.1.0"
+  }
+}