project-graph-mcp 2.2.4 → 2.3.0

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

@@ -0,0 +1,104 @@
+/**
+ * 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

@@ -0,0 +1,185 @@
+/**
+ * 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

@@ -0,0 +1,125 @@
+/**
+ * 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/index.js

@@ -0,0 +1,103 @@
+/**
+ * symbiote-node — Node Graph Editor for Symbiote.js
+ *
+ * Public API for the library.
+ *
+ * @module symbiote-node
+ */
+
+// Core
+export { NodeEditor } from './core/Editor.js';
+export { Node } from './core/Node.js';
+export { Connection } from './core/Connection.js';
+export { Frame } from './core/Frame.js';
+export { Socket, Port, Input, Output, Control, InputControl, uid } from './core/Socket.js';
+export { editorToText, textToGraph, textToEditor } from './core/GraphText.js';
+export { editorToMermaid, mermaidToGraph } from './core/GraphMermaid.js';
+
+// Canvas
+export { NodeCanvas } from './canvas/NodeCanvas/NodeCanvas.js';
+
+// Node components
+export { GraphNode } from './node/GraphNode/GraphNode.js';
+export { NodeSocket } from './node/NodeSocket/NodeSocket.js';
+
+// Interactions
+export { Drag } from './interactions/Drag.js';
+export { Zoom } from './interactions/Zoom.js';
+export { Selector } from './interactions/Selector.js';
+export { SnapGrid } from './interactions/SnapGrid.js';
+export { ConnectFlow } from './interactions/ConnectFlow.js';
+
+// Shapes
+export { NodeShape, RectShape, PillShape, CircleShape, DiamondShape, CommentShape, getShape, registerShape, SVGShape, createSVGShape, SVG_PRESETS } from './shapes/index.js';
+
+// Themes (unified)
+export { applyTheme, extractTheme, DARK_DEFAULT, LIGHT_CLEAN, SYNTHWAVE, GREY_NEUTRAL, NEON_GLOW } from './themes/Theme.js';
+
+// Palette (color-only)
+export { applyPalette, DARK_PALETTE, LIGHT_PALETTE, SYNTHWAVE_PALETTE, GREY_PALETTE } from './themes/Palette.js';
+
+// Skin (geometry-only)
+export { applySkin, MODERN_SKIN, COMPACT_SKIN, ROUNDED_SKIN } from './themes/Skin.js';
+
+// Plugins
+export { Readonly } from './plugins/Readonly.js';
+export { History } from './plugins/History.js';
+
+// Toolbar
+export { QuickToolbar } from './toolbar/QuickToolbar/QuickToolbar.js';
+export { FlowSimulator } from './canvas/FlowSimulator.js';
+
+// Inspector
+export { InspectorPanel } from './inspector/InspectorPanel/InspectorPanel.js';
+
+// Minimap
+export { Minimap } from './canvas/Minimap/Minimap.js';
+
+// Search
+export { NodeSearch } from './canvas/NodeSearch/NodeSearch.js';
+
+// Layout (panel workspace)
+export { Layout } from './layout/Layout/Layout.js';
+export { LayoutNode } from './layout/LayoutNode/LayoutNode.js';
+export { LayoutSidebar } from './layout/LayoutSidebar/LayoutSidebar.js';
+export * as LayoutTree from './layout/LayoutTree.js';
+export {
+  navigate, updateParams, parseQuery, buildHash, buildQuery,
+  getRoute, setDefaultPanel,
+} from './layout/LayoutRouter/LayoutRouter.js';
+export { syncWithRouter } from './layout/LayoutRouter/routerSync.js';
+
+// Auto Layout
+export { computeAutoLayout, computeTreeLayout } from './canvas/AutoLayout.js';
+
+// Portals (Named Reroutes)
+export { PortalManager } from './core/Portal.js';
+
+// Palette Browser
+export { PaletteBrowser } from './palette/PaletteBrowser/PaletteBrowser.js';
+
+// Tabs
+export { GraphTabs } from './canvas/GraphTabs/GraphTabs.js';
+
+// Subgraphs
+export { SubgraphNode } from './core/SubgraphNode.js';
+export { SubgraphManager } from './canvas/SubgraphManager.js';
+export { SubgraphRouter } from './canvas/SubgraphRouter.js';
+export { Breadcrumb } from './canvas/Breadcrumb/Breadcrumb.js';
+
+// Canvas utilities
+export { LODManager } from './canvas/LODManager.js';
+export { PinExpansion } from './canvas/PinExpansion.js';
+export { ForceLayout } from './canvas/ForceLayout.js';
+
+// Additional themes (not in base Theme.js barrel)
+export { CARBON, CARBON_PALETTE } from './themes/carbon.js';
+export { PCB_DARK } from './themes/pcb.js';
+export { EBOOK, EBOOK_PALETTE } from './themes/ebook.js';
+export { NEON_PALETTE } from './themes/neon.js';
+
+// Engine (server-side graph runtime)
+// Usage: import * as Engine from 'symbiote-node/engine'
+// Or: import { Graph, Executor } from 'symbiote-node/engine'