project-graph-mcp 2.3.2 → 2.4.1

package/vendor/symbiote-node/core/Portal.js

@@ -1,104 +0,0 @@
-/**
- * Portal — Named Reroutes for wireless connections
- *
- * Provides virtual sender/receiver pairs that act as invisible
- * connections. PortalManager tracks named channels and resolves
- * portal connections during graph evaluation.
- *
- * Usage:
- *   const pm = new PortalManager();
- *   pm.addSender('channelA', node1, 'output');
- *   pm.addReceiver('channelA', node2, 'input');
- *   pm.getConnections(); // returns virtual connections
- *
- * @module symbiote-node/core/Portal
- */
-
-/**
- * PortalManager — manages named reroute channels
- */
-export class PortalManager {
-  /** @type {Map<string, { senders: Array<{nodeId: string, portKey: string}>, receivers: Array<{nodeId: string, portKey: string}> }>} */
-  #channels = new Map();
-
-  /**
-   * Register a sender portal
-   * @param {string} channel - Named channel
-   * @param {string} nodeId - Source node ID
-   * @param {string} portKey - Output port key
-   */
-  addSender(channel, nodeId, portKey) {
-    if (!this.#channels.has(channel)) {
-      this.#channels.set(channel, { senders: [], receivers: [] });
-    }
-    this.#channels.get(channel).senders.push({ nodeId, portKey });
-  }
-
-  /**
-   * Register a receiver portal
-   * @param {string} channel - Named channel
-   * @param {string} nodeId - Target node ID
-   * @param {string} portKey - Input port key
-   */
-  addReceiver(channel, nodeId, portKey) {
-    if (!this.#channels.has(channel)) {
-      this.#channels.set(channel, { senders: [], receivers: [] });
-    }
-    this.#channels.get(channel).receivers.push({ nodeId, portKey });
-  }
-
-  /**
-   * Remove all portals for a node
-   * @param {string} nodeId
-   */
-  removeNode(nodeId) {
-    for (const [, ch] of this.#channels) {
-      ch.senders = ch.senders.filter(s => s.nodeId !== nodeId);
-      ch.receivers = ch.receivers.filter(r => r.nodeId !== nodeId);
-    }
-  }
-
-  /**
-   * Get all virtual connections from portal channels
-   * @returns {Array<{ from: string, out: string, to: string, in: string, channel: string }>}
-   */
-  getConnections() {
-    const result = [];
-    for (const [channel, ch] of this.#channels) {
-      for (const sender of ch.senders) {
-        for (const receiver of ch.receivers) {
-          result.push({
-            from: sender.nodeId,
-            out: sender.portKey,
-            to: receiver.nodeId,
-            in: receiver.portKey,
-            channel,
-          });
-        }
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Get all channel names
-   * @returns {string[]}
-   */
-  getChannels() {
-    return [...this.#channels.keys()];
-  }
-
-  /**
-   * Get channel info
-   * @param {string} channel
-   * @returns {{ senders: Array, receivers: Array }|undefined}
-   */
-  getChannel(channel) {
-    return this.#channels.get(channel);
-  }
-
-  /** Clear all portals */
-  clear() {
-    this.#channels.clear();
-  }
-}

package/vendor/symbiote-node/core/Socket.js

@@ -1,185 +0,0 @@
-/**
- * Socket — typed port connector
- *
- * Defines the type and visual identity of a connection endpoint.
- * Compatible with symbiote-node SocketTypes system.
- *
- * @module symbiote-node/core/Socket
- */
-
-let _uid = 0;
-
-/**
- * Generate unique ID with prefix
- * @param {string} prefix
- * @returns {string}
- */
-export function uid(prefix = 'id') {
-  return `${prefix}_${(++_uid).toString(36)}_${Date.now().toString(36)}`;
-}
-
-/**
- * Socket type — defines connection endpoint type
- */
-export class Socket {
-  /**
-   * @param {string} name - Socket type name (e.g. 'number', 'string', 'any')
-   * @param {object} [options]
-   * @param {string} [options.color] - CSS color for visual
-   */
-  constructor(name, options = {}) {
-    /** @type {string} */
-    this.name = name;
-
-    /** @type {string} */
-    this.color = options.color || 'var(--clr-3)';
-  }
-
-  /**
-   * Check if this socket is compatible with another
-   * @param {Socket} other
-   * @returns {boolean}
-   */
-  isCompatibleWith(other) {
-    if (this.name === 'any' || other.name === 'any') return true;
-    return this.name === other.name;
-  }
-}
-
-/**
- * Port — represents an input or output endpoint on a node
- */
-export class Port {
-  /**
-   * @param {Socket} socket - Socket type
-   * @param {string} [label] - Display label
-   * @param {boolean} [multipleConnections=false] - Allow multiple connections
-   */
-  constructor(socket, label, multipleConnections = false) {
-    /** @type {string} */
-    this.id = uid('port');
-
-    /** @type {Socket} */
-    this.socket = socket;
-
-    /** @type {string|undefined} */
-    this.label = label;
-
-    /** @type {boolean} */
-    this.multipleConnections = multipleConnections;
-
-    /** @type {number} */
-    this.index = 0;
-  }
-}
-
-/**
- * Input port — accepts incoming connections
- */
-export class Input extends Port {
-  /**
-   * @param {Socket} socket
-   * @param {string} [label]
-   * @param {boolean} [multipleConnections=false]
-   */
-  constructor(socket, label, multipleConnections = false) {
-    super(socket, label, multipleConnections);
-
-    /** @type {Control|null} */
-    this.control = null;
-
-    /** @type {boolean} */
-    this.showControl = true;
-  }
-
-  /**
-   * Add embedded control to this input
-   * @param {Control} control
-   */
-  addControl(control) {
-    if (this.control) throw new Error('control already added for this input');
-    this.control = control;
-  }
-
-  /**
-   * Remove embedded control
-   */
-  removeControl() {
-    this.control = null;
-  }
-}
-
-/**
- * Output port — provides outgoing connections
- */
-export class Output extends Port {
-  /**
-   * @param {Socket} socket
-   * @param {string} [label]
-   * @param {boolean} [multipleConnections=true]
-   */
-  constructor(socket, label, multipleConnections = true) {
-    super(socket, label, multipleConnections);
-  }
-}
-
-/**
- * Control — embeddable UI widget inside a node
- */
-export class Control {
-  constructor() {
-    /** @type {string} */
-    this.id = uid('ctrl');
-
-    /** @type {number} */
-    this.index = 0;
-
-    /** @type {function|undefined} */
-    this._onChange = undefined;
-  }
-}
-
-/**
- * InputControl — text or number input widget
- */
-export class InputControl extends Control {
-  /**
-   * @param {'text'|'number'|'textarea'|'select'|'boolean'} type
-   * @param {object} [options]
-   * @param {boolean} [options.readonly=false]
-   * @param {string|number|boolean} [options.initial]
-   * @param {string} [options.label] - Display label
-   * @param {string[]} [options.options] - Options for select type
-   * @param {function} [options.change] - Callback on value change
-   */
-  constructor(type, options = {}) {
-    super();
-
-    /** @type {'text'|'number'|'textarea'|'select'|'boolean'} */
-    this.type = type;
-
-    /** @type {boolean} */
-    this.readonly = options.readonly || false;
-
-    /** @type {string|number|boolean|undefined} */
-    this.value = options.initial;
-
-    /** @type {string} */
-    this.label = options.label || '';
-
-    /** @type {string[]} */
-    this.options = options.options || [];
-
-    /** @type {function|undefined} */
-    this._onChange = options.change;
-  }
-
-  /**
-   * Set control value
-   * @param {string|number|boolean} value
-   */
-  setValue(value) {
-    this.value = value;
-    if (this._onChange) this._onChange(value);
-  }
-}

package/vendor/symbiote-node/core/SubgraphNode.js

@@ -1,125 +0,0 @@
-/**
- * SubgraphNode — Node containing an embedded graph
- *
- * Extends Node with an inner NodeEditor that holds a sub-pipeline.
- * Ports are auto-generated from exposed inner nodes.
- * Supports drill-down navigation via SubgraphManager.
- *
- * @module symbiote-node/core/SubgraphNode
- */
-
-import { Node } from './Node.js';
-import { NodeEditor } from './Editor.js';
-import { Socket, Input, Output } from './Socket.js';
-
-export class SubgraphNode extends Node {
-  /** @type {NodeEditor} */
-  innerEditor;
-
-  /** @type {Object<string, { x: number, y: number }>} */
-  innerPositions = {};
-
-  /** @type {{ panX: number, panY: number, zoom: number }} */
-  innerTransform = { panX: 0, panY: 0, zoom: 1 };
-
-  /**
-   * @param {string} label - Display name
-   * @param {object} [options={}]
-   * @param {string} [options.category='subgraph']
-   * @param {string} [options.icon='account_tree']
-   */
-  constructor(label, options = {}) {
-    super(label, {
-      type: 'subgraph',
-      category: options.category ?? 'subgraph',
-      icon: options.icon ?? 'account_tree',
-      shape: 'rect',
-      ...options,
-    });
-
-    this.innerEditor = new NodeEditor();
-    this._isSubgraph = true;
-  }
-
-  /**
-   * Sync external ports with inner graph exposed nodes.
-   * Inner nodes with `_exposed: 'input'` become subgraph inputs.
-   * Inner nodes with `_exposed: 'output'` become subgraph outputs.
-   */
-  syncPorts() {
-    // Clear existing auto-ports (keep manually added ones)
-    for (const key of Object.keys(this.inputs)) {
-      if (key.startsWith('sg_')) this.removeInput(key);
-    }
-    for (const key of Object.keys(this.outputs)) {
-      if (key.startsWith('sg_')) this.removeOutput(key);
-    }
-
-    const anySocket = new Socket('any', { color: '#94a3b8' });
-
-    // Find exposed inner nodes
-    for (const innerNode of this.innerEditor.getNodes()) {
-      if (innerNode._exposed === 'input') {
-        for (const [key, output] of Object.entries(innerNode.outputs)) {
-          const portKey = `sg_${innerNode.id}_${key}`;
-          this.addInput(portKey, new Input(
-            output.socket ?? anySocket,
-            innerNode.label ?? key
-          ));
-        }
-      }
-      if (innerNode._exposed === 'output') {
-        for (const [key, input] of Object.entries(innerNode.inputs)) {
-          const portKey = `sg_${innerNode.id}_${key}`;
-          this.addOutput(portKey, new Output(
-            input.socket ?? anySocket,
-            innerNode.label ?? key
-          ));
-        }
-      }
-    }
-  }
-
-  /**
-   * Get inner editor
-   * @returns {NodeEditor}
-   */
-  getInnerEditor() {
-    return this.innerEditor;
-  }
-
-  /**
-   * Save inner node positions
-   * @param {Object<string, { x: number, y: number }>} positions
-   */
-  setInnerPositions(positions) {
-    this.innerPositions = { ...positions };
-  }
-
-  /**
-   * Save inner viewport transform
-   * @param {{ panX: number, panY: number, zoom: number }} transform
-   */
-  setInnerTransform(transform) {
-    this.innerTransform = { ...transform };
-  }
-
-  /**
-   * Serialize subgraph node including inner graph
-   * @returns {object}
-   */
-  toJSON() {
-    return {
-      id: this.id,
-      type: 'subgraph',
-      label: this.label,
-      category: this.category,
-      innerGraph: this.innerEditor.toJSON(
-        Object.fromEntries(
-          Object.entries(this.innerPositions).map(([id, pos]) => [id, [pos.x, pos.y]])
-        )
-      ),
-      innerTransform: this.innerTransform,
-    };
-  }
-}

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

@@ -1,100 +0,0 @@
-/**
- * AgentUICommands.js - Agent UI control command builders
- *
- * Pure data builders for WebSocket messages that control the UI.
- * No WebSocket dependency — produces message objects for P23 bridge to send.
- *
- * @module agi-graph/AgentUICommands
- */
-
-/**
- * @typedef {object} UICommand
- * @property {string} type - Command type (ui:layout, ui:focus, etc.)
- * @property {object} payload - Command payload
- */
-
-/**
- * Switch UI layout — control which panels are visible
- * @param {string[]} panels - Panel names to show
- * @param {string} [split='horizontal'] - Split direction
- * @returns {UICommand}
- */
-export function layout(panels, split = 'horizontal') {
-  return { type: 'ui:layout', payload: { panels, split } };
-}
-
-/**
- * Focus on a specific panel or node
- * @param {string} panel - Panel name to focus
- * @param {string} [nodeId] - Optional node to zoom to
- * @returns {UICommand}
- */
-export function focus(panel, nodeId) {
-  return { type: 'ui:focus', payload: { panel, nodeId } };
-}
-
-/**
- * Select nodes on canvas
- * @param {string[]} nodeIds - Node IDs to select
- * @returns {UICommand}
- */
-export function select(nodeIds) {
-  return { type: 'ui:select', payload: { nodeIds } };
-}
-
-/**
- * Navigate into a compound node
- * @param {string} compoundId - Compound node ID to enter
- * @returns {UICommand}
- */
-export function navigate(compoundId) {
-  return { type: 'ui:navigate', payload: { compoundId } };
-}
-
-/**
- * Control timeline playback
- * @param {'play'|'stop'|'seek'} action - Playback action
- * @param {number} [frame] - Frame to seek to (for 'seek' action)
- * @returns {UICommand}
- */
-export function playback(action, frame) {
-  const payload = { action };
-  if (frame !== undefined) payload.frame = frame;
-  return { type: 'ui:playback', payload };
-}
-
-/**
- * Show notification to user
- * @param {string} message - Notification text
- * @param {'info'|'success'|'warning'|'error'} [type='info'] - Notification type
- * @returns {UICommand}
- */
-export function notify(message, type = 'info') {
-  return { type: 'ui:notify', payload: { message, type } };
-}
-
-/**
- * Move virtual agent cursor on canvas
- * @param {number} x - X position
- * @param {number} y - Y position
- * @param {string} [label] - Cursor label text
- * @returns {UICommand}
- */
-export function cursor(x, y, label) {
-  const payload = { x, y };
-  if (label) payload.label = label;
-  return { type: 'ui:cursor', payload };
-}
-
-/**
- * All command types for reference
- */
-export const COMMAND_TYPES = [
-  'ui:layout',
-  'ui:focus',
-  'ui:select',
-  'ui:navigate',
-  'ui:playback',
-  'ui:notify',
-  'ui:cursor',
-];