project-graph-mcp 2.3.2 → 2.4.0

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

@@ -1,84 +0,0 @@
-/**
- * Persistence.js - File-based graph save/load
- *
- * Serializes Graph to .workflow.json and loads it back.
- * Works in Node.js (fs) and browser (Blob/FileReader).
- *
- * @module agi-graph/Persistence
- */
-
-import { Graph } from './Graph.js';
-
-/**
- * Save graph to JSON string
- * @param {Graph} graph
- * @param {object} [options={}]
- * @param {boolean} [options.pretty=true] - Pretty-print JSON
- * @param {boolean} [options.includeOutput=false] - Include _output cache in export
- * @returns {string} JSON string
- */
-export function serialize(graph, options = {}) {
-  const { pretty = true, includeOutput = false } = options;
-  const data = graph.toJSON();
-
-  // Strip _output unless explicitly requested
-  if (!includeOutput) {
-    data.nodes = data.nodes.map(n => {
-      const { _output, ...rest } = n;
-      return rest;
-    });
-  }
-
-  return JSON.stringify(data, null, pretty ? 2 : 0);
-}
-
-/**
- * Load graph from JSON string
- * @param {string} json
- * @returns {Graph}
- */
-export function deserialize(json) {
-  const data = JSON.parse(json);
-  return new Graph(data);
-}
-
-/**
- * Save graph to file (Node.js)
- * @param {Graph} graph
- * @param {string} filePath
- * @param {object} [options]
- * @returns {Promise<void>}
- */
-export async function saveToFile(graph, filePath, options) {
-  const json = serialize(graph, options);
-  const { writeFile } = await import('node:fs/promises');
-  await writeFile(filePath, json, 'utf-8');
-}
-
-/**
- * Load graph from file (Node.js)
- * @param {string} filePath
- * @returns {Promise<Graph>}
- */
-export async function loadFromFile(filePath) {
-  const { readFile } = await import('node:fs/promises');
-  const json = await readFile(filePath, 'utf-8');
-  return deserialize(json);
-}
-
-/**
- * Download graph as file (Browser)
- * @param {Graph} graph
- * @param {string} [filename='graph.workflow.json']
- * @param {object} [options]
- */
-export function downloadGraph(graph, filename = 'graph.workflow.json', options) {
-  const json = serialize(graph, options);
-  const blob = new Blob([json], { type: 'application/json' });
-  const url = URL.createObjectURL(blob);
-  const a = document.createElement('a');
-  a.href = url;
-  a.download = filename;
-  a.click();
-  URL.revokeObjectURL(url);
-}

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

@@ -1,264 +0,0 @@
-/**
- * Registry.js - Node type and driver registry
- *
- * Central registry for node types, drivers, and domain packs.
- * AI agents use this to discover, compose, and validate nodes.
- *
- * @module agi-graph/Registry
- */
-
-import { areSocketsCompatible, registerSocketTypes } from './SocketTypes.js';
-
-/**
- * @typedef {object} SocketDef
- * @property {string} name - Socket name
- * @property {string} type - Socket type (must be registered in SocketTypes)
- * @property {boolean} [required] - Whether this input is required
- * @property {string} [description] - Human-readable description for AI
- */
-
-/**
- * @typedef {object} ParamDef
- * @property {string} type - Parameter type (string, int, float, boolean, object, array)
- * @property {*} [default] - Default value
- * @property {number} [min] - Min value (for numeric types)
- * @property {number} [max] - Max value (for numeric types)
- * @property {Array} [enum] - Allowed values
- * @property {boolean} [required] - Whether this param is required
- * @property {string} [description] - Human-readable description
- */
-
-/**
- * @typedef {object} Driver
- * @property {string} description - What this node type does (for AI discovery)
- * @property {string[]} [capabilities] - Tags for AI search
- * @property {SocketDef[]} inputs - Input socket definitions
- * @property {SocketDef[]} outputs - Output socket definitions
- * @property {Record<string, ParamDef>} [params] - Parameter definitions
- * @property {object} [dynamicOutputs] - Dynamic socket pattern definition
- * @property {object} [constraints] - Requirements (secrets, SSH, etc.)
- */
-
-/**
- * @typedef {object} NodeTypeDef
- * @property {string} type - Unique node type identifier (e.g., 'ai/llm')
- * @property {Driver} driver - Self-describing driver manifest
- * @property {function} [process] - Execution function: (inputs, params) => outputs
- * @property {string} [icon] - Material icon name for UI
- * @property {string} [category] - Category for UI grouping
- */
-
-/** @type {Map<string, NodeTypeDef>} */
-const _nodeTypes = new Map();
-
-/** @type {Map<string, object>} */
-const _packs = new Map();
-
-/**
- * Register a single node type
- * @param {NodeTypeDef} def
- */
-export function registerNodeType(def) {
-  if (!def.type) throw new Error('Node type definition must have a "type" field');
-  if (!def.driver) throw new Error(`Node type "${def.type}" must have a "driver" field`);
-  _nodeTypes.set(def.type, def);
-}
-
-/**
- * Register a domain pack (batch registration of node types + socket types)
- * @param {object} pack
- * @param {string} pack.name - Pack name
- * @param {Record<string, import('./SocketTypes.js').SocketTypeDef>} [pack.socketTypes]
- * @param {NodeTypeDef[]} pack.nodes - Array of node type definitions
- */
-export function registerPack(pack) {
-  if (!pack.name) throw new Error('Pack must have a "name" field');
-
-  if (pack.socketTypes) {
-    registerSocketTypes(pack.socketTypes);
-  }
-
-  for (const nodeDef of pack.nodes) {
-    registerNodeType(nodeDef);
-  }
-
-  _packs.set(pack.name, pack);
-}
-
-/**
- * Get a node type definition
- * @param {string} type
- * @returns {NodeTypeDef|undefined}
- */
-export function getNodeType(type) {
-  return _nodeTypes.get(type);
-}
-
-/**
- * List all registered node types
- * @returns {Array<{type: string, driver: Driver}>}
- */
-export function listDrivers() {
-  return [..._nodeTypes.values()].map(def => ({
-    type: def.type,
-    driver: def.driver,
-    icon: def.icon,
-    category: def.category,
-  }));
-}
-
-/**
- * Find node types compatible with a given output type
- * @param {string} outputType - Socket type to match against inputs
- * @returns {Array<{type: string, inputSocket: string, driver: Driver}>}
- */
-export function findCompatible(outputType) {
-  const results = [];
-  for (const [type, def] of _nodeTypes) {
-    for (const input of def.driver.inputs) {
-      if (areSocketsCompatible(outputType, input.type)) {
-        results.push({ type, inputSocket: input.name, driver: def.driver });
-      }
-    }
-  }
-  return results;
-}
-
-/**
- * Find node types by capability tag
- * @param {string} capability
- * @returns {Array<{type: string, driver: Driver}>}
- */
-export function findByCapability(capability) {
-  return [..._nodeTypes.values()]
-    .filter(def => def.driver.capabilities?.includes(capability))
-    .map(def => ({ type: def.type, driver: def.driver }));
-}
-
-/**
- * Get node menu grouped by category (for UI context menus)
- * @returns {Array<{category: string, nodes: Array<{type: string, icon: string, description: string}>}>}
- */
-export function getNodeMenu() {
-  const grouped = {};
-  for (const [type, def] of _nodeTypes) {
-    const cat = def.category || type.split('/')[0];
-    if (!grouped[cat]) grouped[cat] = [];
-    grouped[cat].push({
-      type,
-      icon: def.icon,
-      description: def.driver.description,
-    });
-  }
-  return Object.entries(grouped).map(([category, nodes]) => ({ category, nodes }));
-}
-
-/**
- * Register custom drivers from workflow JSON (AI-generated nodes)
- * @param {Array<{type: string, driver: Driver, process: string}>} customDrivers
- */
-export function registerCustomDrivers(customDrivers) {
-  for (const cd of customDrivers) {
-    registerNodeType({
-      type: cd.type,
-      driver: cd.driver,
-      category: cd.type.split('/')[0],
-      // Process stored as string in JSON — needs eval (sandboxed in production)
-      process: cd.process ? new Function('inputs', 'params', cd.process) : null,
-    });
-  }
-}
-
-/**
- * Validate node params against driver schema
- * @param {string} type - Node type
- * @param {object} params - Params to validate
- * @returns {{valid: boolean, errors: string[]}}
- */
-export function validateParams(type, params) {
-  const def = _nodeTypes.get(type);
-  if (!def) return { valid: false, errors: [`Unknown node type: ${type}`] };
-
-  const validationErrors = [];
-  const schema = def.driver.params || {};
-
-  for (const [key, paramDef] of Object.entries(schema)) {
-    const val = params[key];
-
-    if (paramDef.required && (val === undefined || val === null)) {
-      validationErrors.push(`Missing required param: ${key}`);
-      continue;
-    }
-
-    if (val === undefined) continue;
-
-    if (paramDef.enum && !paramDef.enum.includes(val)) {
-      validationErrors.push(`Param "${key}" must be one of: ${paramDef.enum.join(', ')}. Got: ${val}`);
-    }
-
-    if (paramDef.min !== undefined && val < paramDef.min) {
-      validationErrors.push(`Param "${key}" must be >= ${paramDef.min}. Got: ${val}`);
-    }
-
-    if (paramDef.max !== undefined && val > paramDef.max) {
-      validationErrors.push(`Param "${key}" must be <= ${paramDef.max}. Got: ${val}`);
-    }
-  }
-
-  return { valid: validationErrors.length === 0, errors: validationErrors };
-}
-
-/**
- * Get all registered packs
- * @returns {string[]}
- */
-export function listPacks() {
-  return [..._packs.keys()];
-}
-
-/**
- * Clear all registrations (for testing)
- */
-export function clearRegistry() {
-  _nodeTypes.clear();
-  _packs.clear();
-  // Re-register built-in types
-  _registerBuiltins();
-}
-
-/**
- * Register built-in node types (compound infrastructure)
- * @private
- */
-function _registerBuiltins() {
-  _nodeTypes.set('compound/input', {
-    type: 'compound/input',
-    category: 'compound',
-    icon: 'input',
-    driver: {
-      description: 'Input bridge for compound nodes — receives data from parent graph',
-      capabilities: ['compound'],
-      inputs: [],
-      outputs: [{ name: 'data', type: 'any' }],
-      params: {},
-    },
-    process: (_inputs, params) => ({ ...params }),
-  });
-
-  _nodeTypes.set('compound/output', {
-    type: 'compound/output',
-    category: 'compound',
-    icon: 'output',
-    driver: {
-      description: 'Output bridge for compound nodes — sends data to parent graph',
-      capabilities: ['compound'],
-      inputs: [{ name: 'data', type: 'any' }],
-      outputs: [{ name: 'data', type: 'any' }],
-      params: {},
-    },
-    process: (inputs) => ({ ...inputs }),
-  });
-}
-
-// Register built-ins on module load
-_registerBuiltins();

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

@@ -1,79 +0,0 @@
-/**
- * SocketTypes.js - Universal typed socket system
- *
- * Defines socket types for node connections with color coding
- * and compatibility rules. Domain packs register additional types.
- *
- * @module agi-graph/SocketTypes
- */
-
-/**
- * @typedef {object} SocketTypeDef
- * @property {string} color - Hex color for UI rendering
- * @property {string} label - Human-readable label
- * @property {string[]} compatible - Types this socket can connect to
- */
-
-/** @type {Map<string, SocketTypeDef>} */
-const _types = new Map();
-
-/**
- * Register a socket type
- * @param {string} name
- * @param {SocketTypeDef} def
- */
-export function registerSocketType(name, def) {
-  _types.set(name, { ...def, compatible: def.compatible || [name] });
-}
-
-/**
- * Register multiple socket types at once
- * @param {Record<string, SocketTypeDef>} types
- */
-export function registerSocketTypes(types) {
-  for (const [name, def] of Object.entries(types)) {
-    registerSocketType(name, def);
-  }
-}
-
-/**
- * Get socket type definition
- * @param {string} name
- * @returns {SocketTypeDef|undefined}
- */
-export function getSocketType(name) {
-  return _types.get(name);
-}
-
-/**
- * Get all registered socket types
- * @returns {Map<string, SocketTypeDef>}
- */
-export function getAllSocketTypes() {
-  return new Map(_types);
-}
-
-/**
- * Check if two socket types are compatible
- * @param {string} from - Source socket type
- * @param {string} to - Target socket type
- * @returns {boolean}
- */
-export function areSocketsCompatible(from, to) {
-  if (from === 'any' || to === 'any') return true;
-  if (from === to) return true;
-  const fromDef = _types.get(from);
-  if (!fromDef) return false;
-  return fromDef.compatible.includes(to);
-}
-
-// Core socket types (always available)
-registerSocketTypes({
-  any: { color: '#FFFFFF', label: 'Any', compatible: [] },
-  float: { color: '#A1A1A1', label: 'Float', compatible: ['float', 'int'] },
-  int: { color: '#598C5C', label: 'Integer', compatible: ['int', 'float'] },
-  string: { color: '#70B2FF', label: 'String', compatible: ['string'] },
-  boolean: { color: '#CCA6D6', label: 'Boolean', compatible: ['boolean'] },
-  object: { color: '#E09050', label: 'Object', compatible: ['object'] },
-  array: { color: '#50C878', label: 'Array', compatible: ['array'] },
-});