project-graph-mcp 2.3.2 → 2.4.1

package/vendor/symbiote-node/engine/GraphServer.js

@@ -1,353 +0,0 @@
-/**
- * GraphServer.js - WebSocket + HTTP server for symbiote-node *
- * Provides real-time graph synchronization between server and UI clients.
- * Supports file-based workflow watching, handler hot-reload, and server-side execution.
- *
- * Protocol messages follow SPEC.md P23 Agent Bridge specification.
- *
- * @module symbiote-node/GraphServer */
-
-import { createServer as createHttpServer } from 'node:http';
-import { readFile, writeFile, watch as fsWatch } from 'node:fs/promises';
-import { resolve, extname } from 'node:path';
-import { WebSocketServer } from 'ws';
-
-import { Graph } from './Graph.js';
-import { Executor } from './Executor.js';
-import { getNodeType, listDrivers } from './Registry.js';
-import { loadHandlers, watchHandlers } from './HandlerLoader.js';
-
-/**
- * @typedef {object} ServerOptions
- * @property {number} [port=3100] - HTTP/WebSocket port
- * @property {string} [handlersDir] - Directory for .handler.js files
- * @property {string} [workflowFile] - Path to .workflow.json
- * @property {boolean} [watchFiles=true] - Enable file watching
- * @property {boolean} [verbose=false] - Verbose logging
- */
-
-/**
- * Create an symbiote-node server instance * @param {ServerOptions} options
- * @returns {Promise<{server: import('http').Server, wss: WebSocketServer, graph: Graph, close: () => Promise<void>}>}
- */
-export async function createServer(options = {}) {
-  const {
-    port = 3100,
-    handlersDir,
-    workflowFile,
-    watchFiles = true,
-    verbose = false,
-  } = options;
-
-  let graph = new Graph();
-  const executor = new Executor();
-  const watchers = [];
-  const log = verbose ? console.log.bind(console) : () => { };
-
-  // Load initial workflow
-  if (workflowFile) {
-    try {
-      const json = await readFile(resolve(workflowFile), 'utf-8');
-      const data = JSON.parse(json);
-      graph = deserialize(data);
-      log(`📄 Loaded workflow: ${workflowFile} (${graph.nodes.size} nodes)`);
-    } catch (err) {
-      log(`⚠️  Could not load workflow: ${err.message}`);
-    }
-  }
-
-  // Load handler files
-  if (handlersDir) {
-    const dir = resolve(handlersDir);
-    const registered = await loadHandlers(dir);
-    log(`🔧 Loaded ${registered.length} handler(s) from ${handlersDir}`);
-
-    if (watchFiles) {
-      const stopWatch = watchHandlers(dir, (type) => {
-        log(`♻️  Handler reloaded: ${type}`);
-        broadcast({ type: 'registry:add', payload: { type, category: type.split('/')[0] } });
-      });
-      watchers.push(stopWatch);
-    }
-  }
-
-  // ─── HTTP Server ────────────────────────────────────
-
-  const httpServer = createHttpServer(async (req, res) => {
-    const url = new URL(req.url, `http://localhost:${port}`);
-
-    // CORS headers
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-
-    if (req.method === 'OPTIONS') {
-      res.writeHead(200);
-      res.end();
-      return;
-    }
-
-    try {
-      if (url.pathname === '/api/graph' && req.method === 'GET') {
-        const data = graph.toJSON();
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(data));
-        return;
-      }
-
-      if (url.pathname === '/api/graph' && req.method === 'POST') {
-        const body = await readBody(req);
-        const data = JSON.parse(body);
-        graph = new Graph();
-        graph.fromJSON(data);
-        broadcast({ type: 'graph:update', payload: graph.toJSON() });
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true }));
-        return;
-      }
-
-      if (url.pathname === '/api/graph/execute' && req.method === 'POST') {
-        await executeGraph(res);
-        return;
-      }
-
-      if (url.pathname === '/api/registry' && req.method === 'GET') {
-        const drivers = listDrivers();
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(drivers));
-        return;
-      }
-
-      // Health check
-      if (url.pathname === '/api/health') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ status: 'ok', nodes: graph.nodes.size }));
-        return;
-      }
-
-      res.writeHead(404);
-      res.end('Not Found');
-    } catch (err) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: err.message }));
-    }
-  });
-
-  // ─── WebSocket Server ────────────────────────────────
-
-  const wss = new WebSocketServer({ server: httpServer });
-  /** @type {Set<import('ws').WebSocket>} */
-  const clients = new Set();
-
-  wss.on('connection', (ws) => {
-    clients.add(ws);
-    log(`🔌 Client connected (${clients.size} total)`);
-
-    // Send current state on connect
-    ws.send(JSON.stringify({ type: 'graph:update', payload: graph.toJSON() }));
-
-    ws.on('message', async (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        await handleWsMessage(msg, ws);
-      } catch (err) {
-        ws.send(JSON.stringify({ type: 'error', payload: { message: err.message } }));
-      }
-    });
-
-    ws.on('close', () => {
-      clients.delete(ws);
-      log(`🔌 Client disconnected (${clients.size} total)`);
-    });
-  });
-
-  /**
-   * Broadcast message to all connected clients
-   * @param {object} msg
-   * @param {import('ws').WebSocket} [exclude] - Client to exclude
-   */
-  function broadcast(msg, exclude) {
-    const json = JSON.stringify(msg);
-    for (const client of clients) {
-      if (client !== exclude && client.readyState === 1) {
-        client.send(json);
-      }
-    }
-  }
-
-  /**
-   * Handle incoming WebSocket message
-   * @param {{type: string, payload: object}} msg
-   * @param {import('ws').WebSocket} ws
-   */
-  async function handleWsMessage(msg, ws) {
-    const { type, payload } = msg;
-
-    switch (type) {
-      case 'graph:action': {
-        const { action, nodeId, data } = payload;
-
-        switch (action) {
-          case 'addNode': {
-            const id = graph.addNode(data.type, data.params, data.options);
-            broadcast({ type: 'graph:update', payload: graph.toJSON() }, ws);
-            ws.send(JSON.stringify({ type: 'graph:actionResult', payload: { action, nodeId: id } }));
-            break;
-          }
-          case 'removeNode': {
-            graph.removeNode(nodeId);
-            broadcast({ type: 'graph:update', payload: graph.toJSON() }, ws);
-            break;
-          }
-          case 'connect': {
-            const { from, out, to, in: inp } = data;
-            graph.connect(from, out, to, inp);
-            broadcast({ type: 'graph:update', payload: graph.toJSON() }, ws);
-            break;
-          }
-          case 'updateParams': {
-            graph.updateParams(nodeId, data.params);
-            broadcast({ type: 'graph:update', payload: graph.toJSON() }, ws);
-            break;
-          }
-          case 'execute': {
-            await executeAndStream();
-            break;
-          }
-          default:
-            ws.send(JSON.stringify({ type: 'error', payload: { message: `Unknown action: ${action}` } }));
-        }
-        break;
-      }
-
-      // Agent UI commands — forward to all other clients
-      case 'ui:layout':
-      case 'ui:focus':
-      case 'ui:select':
-      case 'ui:navigate':
-      case 'ui:playback':
-      case 'ui:notify':
-      case 'ui:cursor':
-        broadcast(msg, ws);
-        break;
-
-      default:
-        ws.send(JSON.stringify({ type: 'error', payload: { message: `Unknown message type: ${type}` } }));
-    }
-  }
-
-  /**
-   * Execute graph and stream progress via WebSocket
-   */
-  async function executeAndStream() {
-    const result = await executor.run(graph, {
-      onNodeStart: (nodeId) => {
-        broadcast({ type: 'node:progress', payload: { nodeId, progress: 0, phase: 'start' } });
-      },
-      onNodeComplete: (nodeId, output, timeMs) => {
-        const cached = !!(output && output._fromCache);
-        broadcast({ type: 'node:result', payload: { nodeId, status: 'done', cached, timeMs } });
-      },
-      onNodeSkipped: (nodeId) => {
-        broadcast({ type: 'node:result', payload: { nodeId, status: 'skipped' } });
-      },
-    });
-
-    broadcast({ type: 'graph:executed', payload: { totalTime: result.totalTime, log: result.log } });
-
-    // Save to workflow file if configured
-    if (workflowFile) {
-      try {
-        await writeFile(resolve(workflowFile), JSON.stringify(graph.toJSON(), null, 2));
-      } catch (err) {
-        log(`⚠️  Could not save workflow: ${err.message}`);
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Execute graph via HTTP and return result
-   * @param {import('http').ServerResponse} res
-   */
-  async function executeGraph(res) {
-    try {
-      const result = await executeAndStream();
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        ok: true,
-        totalTime: result.totalTime,
-        outputs: result.outputs,
-        log: result.log,
-      }));
-    } catch (err) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: err.message }));
-    }
-  }
-
-  // ─── File Watching ────────────────────────────────
-
-  if (watchFiles && workflowFile) {
-    const wfPath = resolve(workflowFile);
-    let debounce = null;
-    const ac = new AbortController();
-
-    (async () => {
-      try {
-        const watcher = fsWatch(wfPath, { signal: ac.signal });
-        for await (const event of watcher) {
-          if (debounce) clearTimeout(debounce);
-          debounce = setTimeout(async () => {
-            try {
-              const json = await readFile(wfPath, 'utf-8');
-              const data = JSON.parse(json);
-              graph = deserialize(data);
-              broadcast({ type: 'graph:update', payload: data });
-              log(`📄 Workflow reloaded: ${workflowFile}`);
-            } catch (err) {
-              log(`⚠️  Workflow reload error: ${err.message}`);
-            }
-          }, 200);
-        }
-      } catch (err) {
-        if (err.name !== 'AbortError') log(`⚠️  Workflow watch error: ${err.message}`);
-      }
-    })();
-
-    watchers.push(() => ac.abort());
-  }
-
-  // ─── Start & Close ────────────────────────────────
-
-  await new Promise((resolve) => httpServer.listen(port, resolve));
-  log(`🚀 symbiote-node server on http://localhost:${port}`);
-  async function close() {
-    for (const stop of watchers) {
-      if (typeof stop === 'function') stop();
-    }
-    for (const client of clients) {
-      client.close();
-    }
-    wss.close();
-    await new Promise((resolve) => httpServer.close(resolve));
-    log('🛑 Server stopped');
-  }
-
-  return { server: httpServer, wss, graph, executor, broadcast, close };
-}
-
-/**
- * Read HTTP request body
- * @param {import('http').IncomingMessage} req
- * @returns {Promise<string>}
- */
-function readBody(req) {
-  return new Promise((resolve, reject) => {
-    let body = '';
-    req.on('data', (chunk) => { body += chunk; });
-    req.on('end', () => resolve(body));
-    req.on('error', reject);
-  });
-}

package/vendor/symbiote-node/engine/HandlerLoader.js

@@ -1,145 +0,0 @@
-/**
- * HandlerLoader.js - File-based node handler loader
- *
- * Scans directories for .handler.js files and registers them
- * as node types. Supports hot reload via fs.watch.
- *
- * Handler file convention:
- *   export default {
- *     type: 'category/name',
- *     category: 'category',
- *     icon: 'icon_name',
- *     driver: { inputs, outputs, params, ... },
- *     lifecycle: { validate, cacheKey, execute, postProcess },
- *   };
- *
- * @module symbiote-node/HandlerLoader */
-
-import { readdir, stat } from 'node:fs/promises';
-import { join, relative, extname } from 'node:path';
-import { watch } from 'node:fs';
-import { pathToFileURL } from 'node:url';
-import { registerNodeType } from './Registry.js';
-
-/**
- * Recursively find all .handler.js files in a directory
- * @param {string} dir - Directory to scan
- * @returns {Promise<string[]>} Absolute file paths
- */
-async function findHandlerFiles(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch {
-    return results;
-  }
-
-  for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const nested = await findHandlerFiles(fullPath);
-      results.push(...nested);
-    } else if (entry.name.endsWith('.handler.js')) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-
-/**
- * Load a single handler file and register it
- * @param {string} filePath - Absolute path to .handler.js file
- * @returns {Promise<string|null>} Registered type name or null on error
- */
-async function loadHandler(filePath) {
-  const fileUrl = pathToFileURL(filePath).href;
-  // Cache-bust for hot reload
-  const url = `${fileUrl}?t=${Date.now()}`;
-
-  const module = await import(url);
-  const handler = module.default;
-
-  if (!handler?.type) {
-    throw new Error(`Handler file ${filePath} missing 'type' field in default export`);
-  }
-
-  // Build node type definition from handler
-  const nodeDef = {
-    type: handler.type,
-    category: handler.category || handler.type.split('/')[0],
-    icon: handler.icon,
-    driver: handler.driver || {},
-  };
-
-  // Attach lifecycle hooks if present
-  if (handler.lifecycle) {
-    nodeDef.lifecycle = handler.lifecycle;
-  }
-
-  // Attach process function if present (legacy mode)
-  if (handler.process) {
-    nodeDef.process = handler.process;
-  }
-
-  registerNodeType(nodeDef);
-  return handler.type;
-}
-
-/**
- * Scan a directory for .handler.js files and register them
- * @param {string} dir - Directory to scan (e.g., 'nodes/')
- * @returns {Promise<string[]>} List of registered type names
- */
-export async function loadHandlers(dir) {
-  const files = await findHandlerFiles(dir);
-  const registered = [];
-
-  for (const file of files) {
-    try {
-      const type = await loadHandler(file);
-      if (type) registered.push(type);
-    } catch (err) {
-      console.error(`[symbiote-node] Failed to load handler ${relative(dir, file)}: ${err.message}`);    }
-  }
-
-  return registered;
-}
-
-/**
- * Watch a directory for new/changed .handler.js files
- * Auto-registers them on change.
- *
- * @param {string} dir - Directory to watch
- * @param {object} [options={}]
- * @param {function} [options.onRegister] - Callback(type, filePath)
- * @param {function} [options.onError] - Callback(filePath, error)
- * @returns {{close: function}} Watcher handle
- */
-export function watchHandlers(dir, options = {}) {
-  const { onRegister, onError } = options;
-
-  const watcher = watch(dir, { recursive: true }, async (eventType, filename) => {
-    if (!filename?.endsWith('.handler.js')) return;
-
-    const filePath = join(dir, filename);
-
-    // Verify file exists (could be a delete event)
-    try {
-      await stat(filePath);
-    } catch {
-      return; // File deleted, ignore
-    }
-
-    try {
-      const type = await loadHandler(filePath);
-      if (type && onRegister) onRegister(type, filePath);
-    } catch (err) {
-      if (onError) onError(filePath, err);
-      else console.error(`[symbiote-node] Watch error for ${filename}: ${err.message}`);    }
-  });
-
-  return {
-    close: () => watcher.close(),
-  };
-}

package/vendor/symbiote-node/engine/History.js

@@ -1,83 +0,0 @@
-/**
- * History.js - Snapshot-based undo/redo for graphs
- *
- * Stores deep-cloned snapshots of nodes and connections.
- * Framework-agnostic — works with any graph data.
- *
- * @module agi-graph/History
- */
-
-const MAX_HISTORY = 50;
-
-export class History {
-
-  /** @type {Array<{nodes: object[], connections: object[]}>} */
-  _states = [];
-
-  /** @type {number} */
-  _index = -1;
-
-  /**
-   * Push a new state snapshot
-   * @param {object[]} nodes
-   * @param {object[]} connections
-   */
-  push(nodes, connections) {
-    this._states.length = this._index + 1;
-    this._states.push({
-      nodes: JSON.parse(JSON.stringify(nodes)),
-      connections: JSON.parse(JSON.stringify(connections)),
-    });
-    if (this._states.length > MAX_HISTORY) {
-      this._states.shift();
-    }
-    this._index = this._states.length - 1;
-  }
-
-  /**
-   * Undo — return previous state
-   * @returns {{nodes: object[], connections: object[]}|null}
-   */
-  undo() {
-    if (!this.canUndo) return null;
-    this._index--;
-    return this._clone(this._states[this._index]);
-  }
-
-  /**
-   * Redo — return next state
-   * @returns {{nodes: object[], connections: object[]}|null}
-   */
-  redo() {
-    if (!this.canRedo) return null;
-    this._index++;
-    return this._clone(this._states[this._index]);
-  }
-
-  /** @returns {boolean} */
-  get canUndo() { return this._index > 0; }
-
-  /** @returns {boolean} */
-  get canRedo() { return this._index < this._states.length - 1; }
-
-  /** @returns {number} */
-  get depth() { return this._states.length; }
-
-  /** @returns {number} */
-  get index() { return this._index; }
-
-  /** Clear all history */
-  clear() {
-    this._states = [];
-    this._index = -1;
-  }
-
-  /**
-   * @param {{nodes: object[], connections: object[]}} state
-   * @returns {{nodes: object[], connections: object[]}}
-   * @private
-   */
-  _clone(state) {
-    return JSON.parse(JSON.stringify(state));
-  }
-}

package/vendor/symbiote-node/engine/Lifecycle.js

@@ -1,118 +0,0 @@
-/**
- * Lifecycle.js - Node lifecycle pipeline
- *
- * Every node can define lifecycle hooks: validate, cacheKey, execute, postProcess.
- * The lifecycle runner orchestrates these steps with cache awareness.
- *
- * @module agi-graph/Lifecycle
- */
-
-/**
- * @typedef {object} LifecycleHooks
- * @property {function} [validate] - (inputs) => boolean — return false to abort
- * @property {function} [cacheKey] - (inputs, params) => string — custom cache key
- * @property {function} [execute] - (inputs, params) => outputs — main processing (async)
- * @property {function} [postProcess] - (outputs) => outputs — transform before output
- */
-
-/**
- * @typedef {object} CacheState
- * @property {'auto'|'freeze'|'force'} mode - Cache behavior mode
- * @property {Map<string, {key: string, outputs: object}>} store - Cache storage
- * @property {string} nodeId - Current node ID
- */
-
-/**
- * @typedef {object} LifecycleResult
- * @property {object} outputs - Final outputs from the node
- * @property {boolean} cached - Whether result came from cache
- * @property {string|null} error - Error message if validation failed
- * @property {string|null} cacheHash - Cache key used (for UI display)
- */
-
-/**
- * Default cache key: JSON hash of inputs + params
- * @param {object} inputs
- * @param {object} params
- * @returns {string}
- */
-function defaultCacheKey(inputs, params) {
-  return JSON.stringify({ i: inputs, p: params });
-}
-
-/**
- * Run lifecycle pipeline for a node
- *
- * Flow:
- * 1. validate(inputs) → false = abort with error
- * 2. cacheKey(inputs, params) → compute hash
- * 3. Check mode: freeze → return cached; force → skip; auto → check hash
- * 4. execute(inputs, params) → outputs
- * 5. postProcess(outputs) → final outputs
- * 6. Store in cache
- *
- * @param {LifecycleHooks} hooks - Lifecycle hooks from driver
- * @param {object} inputs - Resolved inputs from upstream
- * @param {object} params - Node parameters
- * @param {CacheState} cacheState - Cache state for this node
- * @returns {Promise<LifecycleResult>}
- */
-export async function runLifecycle(hooks, inputs, params, cacheState) {
-  const { mode = 'auto', store, nodeId } = cacheState;
-
-  // Step 1: Validate
-  if (hooks.validate) {
-    try {
-      const valid = hooks.validate(inputs);
-      if (valid === false) {
-        return { outputs: null, cached: false, error: 'Validation failed', cacheHash: null };
-      }
-    } catch (err) {
-      return { outputs: null, cached: false, error: `Validation error: ${err.message}`, cacheHash: null };
-    }
-  }
-
-  // Step 2: Compute cache key
-  const cacheKeyFn = hooks.cacheKey || defaultCacheKey;
-  const cacheHash = cacheKeyFn(inputs, params);
-
-  // Step 3: Check cache based on mode
-  const cached = store.get(nodeId);
-
-  if (mode === 'freeze' && cached) {
-    return { outputs: cached.outputs, cached: true, error: null, cacheHash: cached.key };
-  }
-
-  if (mode === 'auto' && cached && cached.key === cacheHash) {
-    return { outputs: cached.outputs, cached: true, error: null, cacheHash };
-  }
-
-  // mode === 'force' → skip cache check entirely
-
-  // Step 4: Execute
-  const executeFn = hooks.execute;
-  if (!executeFn) {
-    return { outputs: null, cached: false, error: 'No execute hook defined', cacheHash };
-  }
-
-  let outputs;
-  try {
-    outputs = await executeFn(inputs, params);
-  } catch (err) {
-    return { outputs: null, cached: false, error: `Execution error: ${err.message}`, cacheHash };
-  }
-
-  // Step 5: PostProcess
-  if (hooks.postProcess) {
-    try {
-      outputs = hooks.postProcess(outputs);
-    } catch (err) {
-      return { outputs: null, cached: false, error: `PostProcess error: ${err.message}`, cacheHash };
-    }
-  }
-
-  // Step 6: Store in cache
-  store.set(nodeId, { key: cacheHash, outputs });
-
-  return { outputs, cached: false, error: null, cacheHash };
-}