cordenar-mcp 0.1.1

package/db.js

@@ -0,0 +1,95 @@
+// Cordenar MCP — Sync database (sync.db)
+// Stores the synapse_map: cloud synapse UUID ↔ local entity ID
+import Database from 'better-sqlite3';
+import { getDbPath } from './config.js';
+
+let db;
+
+export function initDb() {
+  if (db) return db;
+  const path = getDbPath();
+  db = new Database(path);
+  db.pragma('journal_mode = WAL');
+  db.pragma('busy_timeout = 5000');
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS synapse_map (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      cloud_id      TEXT NOT NULL UNIQUE,
+      source        TEXT NOT NULL,
+      local_id      INTEGER NOT NULL,
+      local_hash    TEXT NOT NULL,
+      cloud_hash    TEXT NOT NULL,
+      direction     TEXT NOT NULL DEFAULT 'push',
+      synced_at     INTEGER NOT NULL DEFAULT (unixepoch())
+    );
+    CREATE INDEX IF NOT EXISTS idx_synapse_map_lookup
+      ON synapse_map(source, local_id);
+    CREATE INDEX IF NOT EXISTS idx_synapse_map_cloud
+      ON synapse_map(cloud_id);
+  `);
+
+  return db;
+}
+
+export function lookupLocal(source, localId) {
+  initDb();
+  return db
+    .prepare('SELECT * FROM synapse_map WHERE source = ? AND local_id = ?')
+    .get(source, localId);
+}
+
+export function lookupCloud(cloudId) {
+  initDb();
+  return db
+    .prepare('SELECT * FROM synapse_map WHERE cloud_id = ?')
+    .get(cloudId);
+}
+
+export function storeMapping({
+  cloud_id,
+  source,
+  local_id,
+  local_hash,
+  cloud_hash,
+  direction,
+}) {
+  initDb();
+  db.prepare(
+    `INSERT INTO synapse_map
+       (cloud_id, source, local_id, local_hash, cloud_hash, direction, synced_at)
+     VALUES (?, ?, ?, ?, ?, ?, unixepoch())
+     ON CONFLICT(cloud_id) DO UPDATE SET
+       local_hash = excluded.local_hash,
+       cloud_hash = excluded.cloud_hash,
+       synced_at = unixepoch()`
+  ).run(cloud_id, source, local_id, local_hash, cloud_hash, direction);
+}
+
+export function removeMapping(cloudId) {
+  initDb();
+  db.prepare('DELETE FROM synapse_map WHERE cloud_id = ?').run(cloudId);
+}
+
+export function getPushEntries() {
+  initDb();
+  return db
+    .prepare("SELECT * FROM synapse_map WHERE direction = 'push'")
+    .all();
+}
+
+export function getPullEntries() {
+  initDb();
+  return db
+    .prepare("SELECT * FROM synapse_map WHERE direction = 'pull'")
+    .all();
+}
+
+export function getDirtyEntries() {
+  initDb();
+  return db
+    .prepare(
+      "SELECT * FROM synapse_map WHERE direction = 'push' AND local_hash != cloud_hash"
+    )
+    .all();
+}

package/embedding.js

@@ -0,0 +1,84 @@
+// Cordenar MCP — MurmurHash3 256-dim LSH embedding
+// Deterministic, no external API, ~2µs per call
+// Identical implementation to Hemisphere and Compend
+const DIM = 256;
+
+function murmurHash3(key, seed = 0) {
+  let h1 = seed >>> 0;
+  const remainder = key.length & 3;
+  const bytes = key.length - remainder;
+  const c1 = 0xcc9e2d51;
+  const c2 = 0x1b873593;
+
+  for (let i = 0; i < bytes; i += 4) {
+    let k1 = (key.charCodeAt(i) & 0xff)
+      | ((key.charCodeAt(i + 1) & 0xff) << 8)
+      | ((key.charCodeAt(i + 2) & 0xff) << 16)
+      | ((key.charCodeAt(i + 3) & 0xff) << 24);
+
+    k1 = Math.imul(k1, c1);
+    k1 = (k1 << 15) | (k1 >>> 17);
+    k1 = Math.imul(k1, c2);
+
+    h1 ^= k1;
+    h1 = (h1 << 13) | (h1 >>> 19);
+    h1 = Math.imul(h1, 5) + 0xe6546b64;
+  }
+
+  if (remainder > 0) {
+    let k1 = 0;
+    for (let j = remainder - 1; j >= 0; j--) {
+      k1 = (k1 << 8) | (key.charCodeAt(bytes + j) & 0xff);
+    }
+    k1 = Math.imul(k1, c1);
+    k1 = (k1 << 15) | (k1 >>> 17);
+    k1 = Math.imul(k1, c2);
+    h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = Math.imul(h1, 0x85ebca6b);
+  h1 ^= h1 >>> 13;
+  h1 = Math.imul(h1, 0xc2b2ae35);
+  h1 ^= h1 >>> 16;
+
+  return h1 >>> 0;
+}
+
+function hashVector(str) {
+  const hash = murmurHash3(str);
+  const idx = hash % DIM;
+  const sign = (hash & 1) ? 1 : -1;
+  return { idx, sign };
+}
+
+export function createEmbedding(text) {
+  const vector = new Float32Array(DIM);
+
+  const tokens = text.toLowerCase().split(/[^\w']+/).filter(t => t.length > 0);
+
+  for (const token of tokens) {
+    const { idx, sign } = hashVector(token);
+    vector[idx] += sign;
+  }
+
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const bigram = tokens[i] + '\x00' + tokens[i + 1];
+    const { idx, sign } = hashVector(bigram);
+    vector[idx] += sign;
+  }
+
+  let sumSq = 0;
+  for (let i = 0; i < DIM; i++) {
+    sumSq += vector[i] * vector[i];
+  }
+  const norm = Math.sqrt(sumSq);
+  if (norm > 0) {
+    for (let i = 0; i < DIM; i++) {
+      vector[i] /= norm;
+    }
+  }
+
+  return vector;
+}

package/index.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import http from 'node:http';
+import { initDb } from './db.js';
+import { getConfig } from './config.js';
+import { listSynapses, shareSynapses, pullSynapses, fullSync } from './sync.js';
+
+const DASH_PORT = getConfig().port;
+
+const db = initDb();
+
+function notifyDash(event, data) {
+  const body = JSON.stringify({ event, ...data });
+  const req = http.request(
+    `http://127.0.0.1:${DASH_PORT}/api/notify`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }
+  );
+  req.on('error', () => {});
+  req.write(body);
+  req.end();
+}
+
+process.on('SIGTERM', () => {
+  try { db.close(); } catch {}
+  process.exit(0);
+});
+process.on('SIGINT', () => {
+  try { db.close(); } catch {}
+  process.exit(0);
+});
+
+const server = new Server(
+  { name: 'cordenar-mcp', version: '0.1.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'cordenar_auth',
+      description:
+        'Authenticate this node with Cordenar cloud via device code OAuth flow. Opens a browser or prints a URL + code for the user to enter in the dashboard.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+    },
+    {
+      name: 'cordenar_status',
+      description:
+        'Show current auth state, node info, pending push count, un-pulled synapse count, and last sync time.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+    },
+    {
+      name: 'cordenar_list',
+      description:
+        'List local synapses (Hemisphere memories + Compend concepts) available for sharing. Supports filters for source, type, and project.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          source: {
+            type: 'string',
+            description: "Filter by source: 'hemisphere' or 'compend'",
+          },
+          type: {
+            type: 'string',
+            description: 'Filter by type: memory kind or concept type',
+          },
+          project: {
+            type: 'string',
+            description: 'Filter Hemisphere memories by project namespace',
+          },
+          limit: {
+            type: 'number',
+            description: 'Max results (default 50)',
+          },
+        },
+        required: [],
+      },
+    },
+    {
+      name: 'cordenar_share',
+      description:
+        'Push selected local synapses to the cloud. Synapses enter pending_approval status until an admin approves them.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          synapses: {
+            type: 'array',
+            description:
+              "Array of { source: 'hemisphere'|'compend', id: number } objects to share",
+            items: {
+              type: 'object',
+              properties: {
+                source: { type: 'string' },
+                id: { type: 'number' },
+              },
+              required: ['source', 'id'],
+            },
+          },
+        },
+        required: ['synapses'],
+      },
+    },
+    {
+      name: 'cordenar_pull',
+      description:
+        'Fetch approved active synapses from your groups and store them locally.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          group_id: {
+            type: 'string',
+            description: 'Optional. Limit pull to a specific group.',
+          },
+        },
+        required: [],
+      },
+    },
+    {
+      name: 'cordenar_sync',
+      description:
+        'Full bidirectional sync: push locally-edited shared synapses, detect and unlink locally-deleted shared synapses, pull new approved synapses from cloud.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    let result;
+    switch (name) {
+      case 'cordenar_auth':
+        result = { message: 'Not yet implemented' };
+        break;
+      case 'cordenar_status':
+        result = { message: 'Not yet implemented' };
+        break;
+      case 'cordenar_list':
+        result = listSynapses(args);
+        break;
+      case 'cordenar_share':
+        result = shareSynapses(args.synapses);
+        notifyDash('synapse_shared', { count: args.synapses?.length || 0 });
+        break;
+      case 'cordenar_pull':
+        result = pullSynapses(args.group_id);
+        notifyDash('synapse_pulled', {});
+        break;
+      case 'cordenar_sync':
+        result = fullSync();
+        if (result.pushed || result.unlinked || result.pulled) {
+          notifyDash('sync_complete', {});
+        }
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return {
+      content: [
+        { type: 'text', text: JSON.stringify(result, null, 2) },
+      ],
+    };
+  } catch (err) {
+    const msg =
+      err.message && err.message.includes('/')
+        ? 'Internal error'
+        : err.message;
+    return {
+      content: [{ type: 'text', text: `Error: ${msg}` }],
+      isError: true,
+    };
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "cordenar-mcp",
+  "version": "0.1.1",
+  "description": "Cloud orchestration MCP server — bridge local Hemisphere/Compend knowledge bases to distributed team synapses",
+  "author": "Hector Jarquin",
+  "type": "module",
+  "license": "MIT",
+  "main": "index.js",
+  "bin": {
+    "cordenar": "dashboard.js"
+  },
+  "scripts": {
+    "start": "node dashboard.js",
+    "stop": "node dashboard.js stop",
+    "restart": "node dashboard.js restart"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hectorjarquin/cordenar-mcp.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@supabase/supabase-js": "^2.0.0",
+    "better-sqlite3": "^11.0.0"
+  }
+}

package/supabase.js

@@ -0,0 +1,32 @@
+// Cordenar MCP — Supabase client wrapper
+import { createClient } from '@supabase/supabase-js';
+import { getConfig } from './config.js';
+import { getAccessToken } from './auth.js';
+
+let _client = null;
+
+export function getSupabase() {
+  if (_client) return _client;
+  const cfg = getConfig();
+  if (!cfg.supabaseUrl || !cfg.supabaseAnonKey) {
+    throw new Error(
+      'Supabase not configured. Set SUPABASE_URL and SUPABASE_ANON_KEY env vars.'
+    );
+  }
+  _client = createClient(cfg.supabaseUrl, cfg.supabaseAnonKey);
+  return _client;
+}
+
+export function getAuthenticatedClient() {
+  const token = getAccessToken();
+  if (!token) {
+    throw new Error(
+      'Not authenticated. Run cordenar_auth first.'
+    );
+  }
+  // Create a fresh client with the user's JWT for RLS-scoped queries
+  const cfg = getConfig();
+  return createClient(cfg.supabaseUrl, cfg.supabaseAnonKey, {
+    global: { headers: { Authorization: `Bearer ${token}` } },
+  });
+}

package/sync.js

@@ -0,0 +1,117 @@
+// Cordenar MCP — Sync logic
+// Push, pull, hash-diff, unlink, and SSE revocation
+import { createHash } from 'node:crypto';
+import Database from 'better-sqlite3';
+import { initDb, lookupLocal, lookupCloud, storeMapping, removeMapping, getPushEntries, getDirtyEntries } from './db.js';
+import { getConfig } from './config.js';
+
+export function hashContent(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+// ── cordenar_list ──────────────────────────────────────────────
+
+export function listSynapses({ source, type, project, limit = 50 } = {}) {
+  const results = [];
+  let db;
+
+  if (!source || source === 'hemisphere') {
+    db = openHemisphereReadOnly();
+    const memories = db
+      .prepare(
+        `SELECT id, project, kind, status, substr(content, 1, 200) as preview, created_at
+         FROM memories
+         WHERE deleted_at IS NULL AND archived_at IS NULL
+         ${project ? 'AND project = ?' : ''}
+         ${type ? 'AND kind = ?' : ''}
+         ORDER BY created_at DESC LIMIT ?`
+      )
+      .all(
+        ...[project, type, limit].filter((v) => v !== undefined && v !== null && v !== '')
+      );
+    for (const m of memories) {
+      results.push({
+        source: 'hemisphere',
+        id: m.id,
+        type: m.kind,
+        project: m.project,
+        status: m.status,
+        preview: m.preview,
+        created_at: m.created_at,
+        already_shared: !!lookupLocal('hemisphere', m.id),
+      });
+    }
+    db.close();
+  }
+
+  if (!source || source === 'compend') {
+    db = openCompendReadOnly();
+    const concepts = db
+      .prepare(
+        `SELECT id, slug, type, title, status, description,
+                substr(body, 1, 200) as preview, body, created_at
+         FROM concepts
+         WHERE source = 'local'
+         ${type ? 'AND type = ?' : ''}
+         ORDER BY created_at DESC LIMIT ?`
+      )
+      .all(...[type, limit].filter((v) => v !== undefined && v !== null && v !== ''));
+    for (const c of concepts) {
+      results.push({
+        source: 'compend',
+        id: c.id,
+        type: c.type,
+        slug: c.slug,
+        title: c.title,
+        description: c.description,
+        preview: c.preview,
+        body: c.body,
+        status: c.status,
+        created_at: c.created_at,
+        already_shared: !!lookupLocal('compend', c.id),
+      });
+    }
+    db.close();
+  }
+
+  return results.sort((a, b) => b.created_at - a.created_at);
+}
+
+// ── cordenar_share ─────────────────────────────────────────────
+
+export function shareSynapses(synapses) {
+  const shared = [];
+  for (const { source, id } of synapses) {
+    const existing = lookupLocal(source, id);
+    if (existing) {
+      shared.push({ source, id, status: 'already_shared', cloud_id: existing.cloud_id });
+      continue;
+    }
+    shared.push({ source, id, status: 'not_implemented' });
+  }
+  return { shared };
+}
+
+// ── cordenar_pull ──────────────────────────────────────────────
+
+export function pullSynapses(groupId) {
+  return { pulled: 0, message: 'Not yet implemented' };
+}
+
+// ── cordenar_sync ──────────────────────────────────────────────
+
+export function fullSync() {
+  return { pushed: 0, unlinked: 0, pulled: 0, message: 'Not yet implemented' };
+}
+
+// ── Local DB read-only helpers ─────────────────────────────────
+
+function openHemisphereReadOnly() {
+  const cfg = getConfig();
+  return new Database(cfg.hemisphereDb, { readonly: true });
+}
+
+function openCompendReadOnly() {
+  const cfg = getConfig();
+  return new Database(cfg.compendDb, { readonly: true });
+}