@sym-bot/sym 0.1.0

package/lib/claude-memory-bridge.js

@@ -0,0 +1,217 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * ClaudeMemoryBridge — connects Claude Code's memory system to the SYM mesh.
+ *
+ * Watches Claude Code's project memory directory for changes.
+ * When Claude Code saves a memory, the bridge:
+ *   1. Re-encodes the node's cognitive state from all Claude memories
+ *   2. Shares the new memory with cognitively aligned peers
+ *
+ * When a peer memory arrives through the coupling engine:
+ *   1. Writes it as a .md file in Claude Code's memory directory
+ *   2. Updates MEMORY.md index so Claude Code sees it next conversation
+ *
+ * The user never types sym_remember. The mesh is invisible.
+ */
+class ClaudeMemoryBridge {
+
+  constructor(node, opts = {}) {
+    this._node = node;
+    this._projectDir = opts.projectDir;
+    this._memoryDir = null;
+    this._watcher = null;
+    this._writtenByUs = new Set();
+    this._knownFiles = new Map();
+    this._started = false;
+  }
+
+  start() {
+    if (this._started) return;
+
+    this._memoryDir = this._resolveMemoryDir();
+    if (!this._memoryDir || !fs.existsSync(this._memoryDir)) return;
+
+    this._started = true;
+
+    // Build initial cognitive state from existing Claude memories
+    this._syncCognitiveState();
+
+    // Watch for new/changed memory files
+    this._watcher = fs.watch(this._memoryDir, (eventType, filename) => {
+      if (!filename || !filename.endsWith('.md') || filename === 'MEMORY.md') return;
+      if (this._writtenByUs.has(filename)) {
+        this._writtenByUs.delete(filename);
+        return;
+      }
+      setTimeout(() => this._onMemoryChanged(filename), 300);
+    });
+
+    // Receive peer memories from mesh
+    this._node.on('memory-received', ({ from, entry }) => {
+      this._writePeerMemory(from, entry);
+    });
+  }
+
+  stop() {
+    if (this._watcher) {
+      this._watcher.close();
+      this._watcher = null;
+    }
+    this._started = false;
+  }
+
+  // ── Memory Directory Resolution ──────────────────────────────
+
+  _resolveMemoryDir() {
+    const projectDir = this._projectDir || this._detectProjectDir();
+    if (!projectDir) return null;
+
+    const key = projectDir.replace(/\//g, '-');
+    return path.join(os.homedir(), '.claude', 'projects', key, 'memory');
+  }
+
+  _detectProjectDir() {
+    // The MCP server's CWD may differ from Claude Code's project dir.
+    // Try common patterns to find the right Claude project memory directory.
+    const claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(claudeProjectsDir)) return null;
+
+    const cwd = process.cwd();
+    const cwdKey = cwd.replace(/\//g, '-');
+
+    // Direct match: CWD maps to a project directory
+    const directPath = path.join(claudeProjectsDir, cwdKey, 'memory');
+    if (fs.existsSync(directPath)) return cwd;
+
+    // Walk up: CWD might be a subdirectory of the Claude project
+    let dir = cwd;
+    while (dir !== path.dirname(dir)) {
+      dir = path.dirname(dir);
+      const key = dir.replace(/\//g, '-');
+      const memDir = path.join(claudeProjectsDir, key, 'memory');
+      if (fs.existsSync(memDir)) return dir;
+    }
+
+    return null;
+  }
+
+  // ── Cognitive State from Claude Memories ─────────────────────
+
+  _syncCognitiveState() {
+    const context = this._readAllMemories();
+    if (context.length > 5) {
+      this._node.updateContext(context);
+    }
+  }
+
+  _readAllMemories() {
+    if (!fs.existsSync(this._memoryDir)) return '';
+
+    const files = fs.readdirSync(this._memoryDir)
+      .filter(f => f.endsWith('.md') && f !== 'MEMORY.md');
+
+    const contents = [];
+    for (const file of files) {
+      try {
+        const raw = fs.readFileSync(path.join(this._memoryDir, file), 'utf8');
+        const content = this._extractContent(raw);
+        if (content) contents.push(content);
+        const stat = fs.statSync(path.join(this._memoryDir, file));
+        this._knownFiles.set(file, stat.mtimeMs);
+      } catch {}
+    }
+    return contents.join('\n');
+  }
+
+  _extractContent(raw) {
+    const match = raw.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
+    const body = match ? match[1].trim() : raw.trim();
+    return body || null;
+  }
+
+  // ── Outbound: Claude Memory → Mesh ──────────────────────────
+
+  _onMemoryChanged(filename) {
+    const filePath = path.join(this._memoryDir, filename);
+    if (!fs.existsSync(filePath)) return;
+
+    const stat = fs.statSync(filePath);
+    const knownMtime = this._knownFiles.get(filename);
+    if (knownMtime && Math.abs(stat.mtimeMs - knownMtime) < 100) return;
+    this._knownFiles.set(filename, stat.mtimeMs);
+
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const content = this._extractContent(raw);
+    if (!content) return;
+
+    // Re-encode cognitive state from all memories, then share this one
+    this._syncCognitiveState();
+    this._node.shareWithPeers(content, { source: filename });
+  }
+
+  // ── Inbound: Mesh → Claude Memory ──────────────────────────
+
+  _writePeerMemory(peerName, entry) {
+    if (!this._memoryDir) return;
+    if (!fs.existsSync(this._memoryDir)) {
+      fs.mkdirSync(this._memoryDir, { recursive: true });
+    }
+
+    const safeName = peerName.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const ts = Date.now();
+    const filename = `mesh_${safeName}_${ts}.md`;
+    const filePath = path.join(this._memoryDir, filename);
+    const preview = (entry.content || '').slice(0, 80).replace(/\n/g, ' ');
+
+    const md = [
+      '---',
+      `name: mesh_${safeName}_${ts}`,
+      `description: "[mesh: ${peerName}] ${preview}"`,
+      'type: project',
+      '---',
+      '',
+      `**[mesh: ${peerName}]** ${entry.content}`,
+      '',
+    ].join('\n');
+
+    this._writtenByUs.add(filename);
+    fs.writeFileSync(filePath, md);
+    this._knownFiles.set(filename, ts);
+
+    this._updateMemoryIndex(filename, peerName, entry);
+  }
+
+  _updateMemoryIndex(filename, peerName, entry) {
+    const indexPath = path.join(this._memoryDir, 'MEMORY.md');
+    if (!fs.existsSync(indexPath)) return;
+
+    let index = fs.readFileSync(indexPath, 'utf8');
+
+    // Add Mesh section if absent
+    if (!index.includes('## Mesh')) {
+      index = index.trimEnd() + '\n\n## Mesh\n';
+    }
+
+    const preview = (entry.content || '').slice(0, 60).replace(/\n/g, ' ');
+    const line = `- [${filename}](${filename}) — [mesh: ${peerName}] ${preview}\n`;
+
+    // Insert under ## Mesh
+    const meshStart = index.indexOf('## Mesh');
+    const sectionEnd = index.indexOf('\n## ', meshStart + 7);
+    if (sectionEnd === -1) {
+      index = index.trimEnd() + '\n' + line;
+    } else {
+      index = index.slice(0, sectionEnd) + line + index.slice(sectionEnd);
+    }
+
+    this._writtenByUs.add('MEMORY.md');
+    fs.writeFileSync(indexPath, index);
+  }
+}
+
+module.exports = { ClaudeMemoryBridge };

package/lib/config.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+const os = require('os');
+
+const SYM_DIR = path.join(process.env.HOME || os.homedir(), '.sym');
+const NODES_DIR = path.join(SYM_DIR, 'nodes');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function nodeDir(name) {
+  return path.join(NODES_DIR, name);
+}
+
+function loadOrCreateIdentity(name) {
+  const dir = nodeDir(name);
+  ensureDir(dir);
+  const idPath = path.join(dir, 'identity.json');
+  if (fs.existsSync(idPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(idPath, 'utf8'));
+    } catch {}
+  }
+  const identity = {
+    nodeId: crypto.randomUUID(),
+    name,
+    hostname: os.hostname(),
+    createdAt: Date.now(),
+  };
+  fs.writeFileSync(idPath, JSON.stringify(identity, null, 2));
+  return identity;
+}
+
+function log(nodeName, msg) {
+  const ts = new Date().toISOString().slice(11, 19);
+  console.log(`[${ts}] [${nodeName}] ${msg}`);
+}
+
+module.exports = {
+  SYM_DIR,
+  NODES_DIR,
+  ensureDir,
+  nodeDir,
+  loadOrCreateIdentity,
+  log,
+};

package/lib/context-encoder.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const DIM = 32; // Hidden state dimension per vector (h1[32] + h2[32])
+
+/**
+ * Encodes text context into hidden state vectors (h1, h2) using
+ * deterministic n-gram hashing. Similar text produces similar vectors.
+ * No API key required. Zero cost.
+ */
+function encode(text) {
+  const embDim = DIM * 2;
+  const vec = new Float64Array(embDim);
+  const normalized = text.toLowerCase().replace(/[^a-z0-9 ]/g, ' ');
+  const words = normalized.split(/\s+/).filter(w => w.length > 0);
+
+  // Character trigram hashing
+  for (const word of words) {
+    const padded = ` ${word} `;
+    for (let i = 0; i < padded.length - 2; i++) {
+      const trigram = padded.slice(i, i + 3);
+      const hash = hashString(trigram);
+      const idx = Math.abs(hash) % embDim;
+      vec[idx] += (hash > 0) ? 1 : -1;
+    }
+  }
+
+  // Word-level hashing
+  for (let i = 0; i < words.length; i++) {
+    const hash = hashString(words[i]);
+    const idx = Math.abs(hash) % embDim;
+    vec[idx] += (hash > 0) ? 2 : -2;
+
+    if (i < words.length - 1) {
+      const bigramHash = hashString(`${words[i]}_${words[i + 1]}`);
+      const biIdx = Math.abs(bigramHash) % embDim;
+      vec[biIdx] += (bigramHash > 0) ? 1.5 : -1.5;
+    }
+  }
+
+  // L2 normalize
+  let norm = 0;
+  for (let i = 0; i < embDim; i++) norm += vec[i] * vec[i];
+  norm = Math.sqrt(norm) || 1;
+
+  const h1 = new Array(DIM);
+  const h2 = new Array(DIM);
+  for (let i = 0; i < DIM; i++) {
+    h1[i] = vec[i] / norm;
+    h2[i] = vec[DIM + i] / norm;
+  }
+
+  return { h1, h2 };
+}
+
+function hashString(str) {
+  const hash = crypto.createHash('md5').update(str).digest();
+  return hash.readInt32LE(0);
+}
+
+module.exports = { encode, DIM };

package/lib/frame-parser.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { EventEmitter } = require('events');
+
+const MAX_FRAME_SIZE = 1024 * 1024;
+
+class FrameParser extends EventEmitter {
+  constructor() {
+    super();
+    this.buffer = Buffer.alloc(0);
+    this.state = 'length';
+    this.frameLength = 0;
+  }
+
+  feed(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    this._parse();
+  }
+
+  _parse() {
+    while (true) {
+      if (this.state === 'length') {
+        if (this.buffer.length < 4) return;
+        this.frameLength = this.buffer.readUInt32BE(0);
+        this.buffer = this.buffer.subarray(4);
+        if (this.frameLength === 0 || this.frameLength > MAX_FRAME_SIZE) {
+          this.emit('error', new Error(`Invalid frame length: ${this.frameLength}`));
+          return;
+        }
+        this.state = 'payload';
+      }
+      if (this.state === 'payload') {
+        if (this.buffer.length < this.frameLength) return;
+        const payload = this.buffer.subarray(0, this.frameLength);
+        this.buffer = this.buffer.subarray(this.frameLength);
+        this.state = 'length';
+        this.frameLength = 0;
+        try {
+          this.emit('message', JSON.parse(payload.toString('utf8')));
+        } catch (e) {
+          this.emit('error', new Error(`Invalid JSON: ${e.message}`));
+        }
+      }
+    }
+  }
+}
+
+function sendFrame(socket, msg) {
+  const payload = Buffer.from(JSON.stringify(msg), 'utf8');
+  if (payload.length > MAX_FRAME_SIZE) return false;
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(payload.length, 0);
+  try {
+    socket.write(Buffer.concat([header, payload]));
+    return true;
+  } catch { return false; }
+}
+
+module.exports = { FrameParser, sendFrame };

package/lib/memory-store.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { ensureDir } = require('./config');
+
+class MemoryStore {
+  constructor(memoriesDir, sourceName) {
+    this._dir = memoriesDir;
+    this._source = sourceName;
+    ensureDir(path.join(this._dir, 'local'));
+  }
+
+  write(content, opts = {}) {
+    const dir = path.join(this._dir, 'local');
+    ensureDir(dir);
+    const entry = {
+      key: opts.key || `memory-${Date.now()}`,
+      content,
+      source: this._source,
+      tags: opts.tags || [],
+      timestamp: Date.now(),
+    };
+    fs.writeFileSync(path.join(dir, `${entry.timestamp}.json`), JSON.stringify(entry, null, 2));
+    return entry;
+  }
+
+  receiveFromPeer(peerId, entry) {
+    const dir = path.join(this._dir, peerId);
+    ensureDir(dir);
+    const filename = `${entry.timestamp || Date.now()}.json`;
+    fs.writeFileSync(path.join(dir, filename), JSON.stringify(entry, null, 2));
+  }
+
+  search(query) {
+    const results = [];
+    const q = query.toLowerCase();
+    if (!fs.existsSync(this._dir)) return results;
+
+    const dirs = fs.readdirSync(this._dir, { withFileTypes: true })
+      .filter(d => d.isDirectory()).map(d => d.name);
+
+    for (const dir of dirs) {
+      const dirPath = path.join(this._dir, dir);
+      const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        try {
+          const entry = JSON.parse(fs.readFileSync(path.join(dirPath, file), 'utf8'));
+          const searchable = [
+            entry.content || '',
+            entry.key || '',
+            ...(entry.tags || []),
+          ].join(' ').toLowerCase();
+          if (searchable.includes(q)) {
+            results.push({
+              ...entry,
+              _source: dir === 'local' ? this._source : dir.slice(0, 8),
+              _dir: dir,
+            });
+          }
+        } catch {}
+      }
+    }
+    return results.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+  }
+
+  count() {
+    let total = 0;
+    if (!fs.existsSync(this._dir)) return 0;
+    const dirs = fs.readdirSync(this._dir, { withFileTypes: true })
+      .filter(d => d.isDirectory()).map(d => d.name);
+    for (const dir of dirs) {
+      const dirPath = path.join(this._dir, dir);
+      total += fs.readdirSync(dirPath).filter(f => f.endsWith('.json')).length;
+    }
+    return total;
+  }
+
+  allEntries() {
+    const entries = [];
+    if (!fs.existsSync(this._dir)) return entries;
+    const dirs = fs.readdirSync(this._dir, { withFileTypes: true })
+      .filter(d => d.isDirectory()).map(d => d.name);
+    for (const dir of dirs) {
+      const dirPath = path.join(this._dir, dir);
+      const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.json'));
+      for (const file of files.slice(-10)) {
+        try {
+          entries.push(JSON.parse(fs.readFileSync(path.join(dirPath, file), 'utf8')));
+        } catch {}
+      }
+    }
+    return entries.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+  }
+}
+
+module.exports = { MemoryStore };