project-graph-mcp 2.3.1 → 2.3.2

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

@@ -0,0 +1,79 @@
+/**
+ * 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'] },
+});

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

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+
+/**
+ * cli.js - AGI-Graph command-line runner
+ *
+ * Execute, validate, and inspect workflow JSON files.
+ *
+ * Usage:
+ *   node symbiote-node/cli.js run <workflow.json> [--pack custom] [--secrets secrets.json] [--verbose]
+ *   node symbiote-node/cli.js validate <workflow.json> [--pack custom]
+ *   node symbiote-node/cli.js list [--pack custom]
+ *   node symbiote-node/cli.js inspect <workflow.json>
+ *
+ * @module symbiote-node/cli */
+
+import { readFile } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { performance } from 'node:perf_hooks';
+
+import {
+  Graph,
+  Executor,
+  listDrivers,
+  getNodeType,
+  findCompatible,
+  getNodeMenu,
+  validateParams,
+  deserialize,
+  clearRegistry,
+  loadHandlers,
+  createServer,
+} from './index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ─── Argument Parsing ────────────────────────────────────────────────────────
+
+/**
+ * Parse CLI arguments into command and options
+ * @param {string[]} argv
+ * @returns {{command: string, target: string, options: Record<string, string|boolean>}}
+ */
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const command = args[0];
+  let target = '';
+  /** @type {Record<string, string|boolean>} */
+  const options = {};
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith('--')) {
+        options[key] = next;
+        i++;
+      } else {
+        options[key] = true;
+      }
+    } else if (!target) {
+      target = args[i];
+    }
+  }
+
+  return { command, target, options };
+}
+
+// ─── Secrets Loader ──────────────────────────────────────────────────────────
+
+/**
+ * Load secrets from JSON file
+ * @param {string} [secretsPath]
+ * @returns {Promise<Record<string, string>>}
+ */
+async function loadSecrets(secretsPath) {
+  if (!secretsPath) {
+    // Try default location
+    const defaultPath = resolve(process.cwd(), 'secrets.json');
+    try {
+      const data = await readFile(defaultPath, 'utf-8');
+      return JSON.parse(data);
+    } catch {
+      return {};
+    }
+  }
+
+  try {
+    const data = await readFile(resolve(secretsPath), 'utf-8');
+    return JSON.parse(data);
+  } catch (err) {
+    console.error(`⚠ Could not load secrets from ${secretsPath}: ${err.message}`);
+    return {};
+  }
+}
+
+// ─── Pack Loader ─────────────────────────────────────────────────────────────
+
+/**
+ * Load domain packs by name
+ * @param {string|string[]} packs
+ */
+async function loadPacks(packs) {
+  const packList = Array.isArray(packs) ? packs : packs.split(',');
+  for (const pack of packList) {
+    const packName = pack.trim();
+    try {
+      await import(`./packs/${packName}-pack.js`);
+      console.log(`  ✔ Pack loaded: ${packName}`);
+    } catch (err) {
+      console.error(`  ✖ Failed to load pack "${packName}": ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+// ─── Commands ────────────────────────────────────────────────────────────────
+
+/**
+ * Run a workflow JSON file
+ * @param {string} filePath
+ * @param {Record<string, string|boolean>} options
+ */
+async function cmdRun(filePath, options) {
+  const verbose = !!options.verbose;
+  console.log(`\n🚀 symbiote-node run: ${filePath}\n`);
+  // Load packs
+  if (options.pack) {
+    await loadPacks(/** @type {string} */(options.pack));
+  }
+
+  // Load handler files
+  if (options.handlers) {
+    const dir = resolve(/** @type {string} */(options.handlers));
+    const types = await loadHandlers(dir);
+    if (verbose) console.log(`  🔧 Loaded ${types.length} handler(s) from ${options.handlers}`);
+  }
+
+  // Load secrets
+  const secrets = await loadSecrets(/** @type {string|undefined} */(options.secrets));
+  if (Object.keys(secrets).length > 0 && verbose) {
+    console.log(`  🔑 Secrets loaded: ${Object.keys(secrets).join(', ')}`);
+  }
+
+  // Load workflow
+  const raw = await readFile(resolve(filePath), 'utf-8');
+  const workflowData = JSON.parse(raw);
+
+  console.log(`  📄 Workflow: ${workflowData.name || workflowData.id}`);
+  console.log(`  📊 Nodes: ${workflowData.nodes?.length || 0}`);
+  console.log(`  🔗 Connections: ${workflowData.connections?.length || 0}`);
+  console.log();
+
+  // Deserialize into Graph
+  const graph = deserialize(raw);
+
+  // Execute
+  const executor = new Executor();
+  const t0 = performance.now();
+
+  try {
+    const result = await executor.run(graph, {
+      cache: workflowData.execution?.cache,
+      secrets,
+    });
+
+    const elapsed = (performance.now() - t0).toFixed(1);
+    console.log(`  ✔ Execution complete in ${elapsed}ms`);
+    console.log(`  📋 Execution order: ${result.executionOrder.length} nodes`);
+
+    if (verbose) {
+      console.log('\n  Execution log:');
+      for (const entry of result.log) {
+        const status = entry.skipped ? '⏭ skipped' : `✔ ${entry.time.toFixed(2)}ms`;
+        const nodeData = graph.getNode(entry.nodeId);
+        console.log(`    ${nodeData?.name || entry.nodeId}: ${status}`);
+      }
+
+      console.log('\n  Outputs:');
+      for (const [nodeId, output] of Object.entries(result.outputs)) {
+        const nodeData = graph.getNode(nodeId);
+        console.log(`    ${nodeData?.name || nodeId}:`, JSON.stringify(output, null, 2).slice(0, 200));
+      }
+    }
+
+    // Summary
+    const outputNodes = result.executionOrder.filter(id => {
+      const node = graph.getNode(id);
+      return node?.type?.startsWith('output/');
+    });
+
+    if (outputNodes.length > 0) {
+      console.log(`\n  Output nodes:`);
+      for (const id of outputNodes) {
+        const node = graph.getNode(id);
+        console.log(`    → ${node.name || node.type} (${id})`);
+      }
+    }
+
+    console.log(`\n✅ Done\n`);
+
+  } catch (err) {
+    const elapsed = (performance.now() - t0).toFixed(1);
+    console.error(`\n  ✖ Execution failed after ${elapsed}ms: ${err.message}\n`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Validate a workflow JSON file without executing
+ * @param {string} filePath
+ * @param {Record<string, string|boolean>} options
+ */
+async function cmdValidate(filePath, options) {
+  console.log(`\n🔍 symbiote-node validate: ${filePath}\n`);
+  if (options.pack) {
+    await loadPacks(/** @type {string} */(options.pack));
+  }
+
+  if (options.handlers) {
+    const dir = resolve(/** @type {string} */(options.handlers));
+    await loadHandlers(dir);
+  }
+
+  const raw = await readFile(resolve(filePath), 'utf-8');
+  const data = JSON.parse(raw);
+
+  let errors = 0;
+  let warnings = 0;
+
+  // Check all node types exist
+  for (const node of (data.nodes || [])) {
+    const typeDef = getNodeType(node.type);
+    if (!typeDef) {
+      console.error(`  ✖ Unknown node type: ${node.type} (node: ${node.id})`);
+      errors++;
+      continue;
+    }
+
+    // Validate params
+    const validation = validateParams(node.type, node.params || {});
+    if (!validation.valid) {
+      for (const err of validation.errors) {
+        console.error(`  ✖ ${node.id} (${node.type}): ${err}`);
+        errors++;
+      }
+    }
+  }
+
+  // Check connections reference valid nodes
+  const nodeIds = new Set((data.nodes || []).map(n => n.id));
+  for (const conn of (data.connections || [])) {
+    if (!nodeIds.has(conn.from)) {
+      console.error(`  ✖ Connection references unknown source node: ${conn.from}`);
+      errors++;
+    }
+    if (!nodeIds.has(conn.to)) {
+      console.error(`  ✖ Connection references unknown target node: ${conn.to}`);
+      errors++;
+    }
+  }
+
+  // Check for nodes with no connections (orphans)
+  const connectedNodes = new Set();
+  for (const conn of (data.connections || [])) {
+    connectedNodes.add(conn.from);
+    connectedNodes.add(conn.to);
+  }
+  for (const node of (data.nodes || [])) {
+    if (!connectedNodes.has(node.id)) {
+      console.warn(`  ⚠ Orphan node: ${node.id} (${node.type})`);
+      warnings++;
+    }
+  }
+
+  console.log();
+  if (errors === 0) {
+    console.log(`  ✅ Valid (${warnings} warning${warnings !== 1 ? 's' : ''})\n`);
+  } else {
+    console.error(`  ❌ ${errors} error${errors !== 1 ? 's' : ''}, ${warnings} warning${warnings !== 1 ? 's' : ''}\n`);
+    process.exit(1);
+  }
+}
+
+/**
+ * List all registered node types
+ * @param {Record<string, string|boolean>} options
+ */
+async function cmdList(options) {
+  console.log(`\n📋 symbiote-node node types\n`);
+  if (options.pack) {
+    await loadPacks(/** @type {string} */(options.pack));
+  }
+
+  if (options.handlers) {
+    const dir = resolve(/** @type {string} */(options.handlers));
+    await loadHandlers(dir);
+  }
+
+  const menu = getNodeMenu();
+  for (const group of menu) {
+    console.log(`  ═══ ${group.category.toUpperCase()} ═══`);
+    for (const node of group.nodes) {
+      const typeDef = getNodeType(node.type);
+      const ins = typeDef?.driver.inputs?.length || 0;
+      const outs = typeDef?.driver.outputs?.length || 0;
+      console.log(`    ${node.type}  [${ins}→${outs}]  ${node.description || ''}`);
+    }
+    console.log();
+  }
+
+  const total = listDrivers().length;
+  console.log(`  Total: ${total} node types\n`);
+}
+
+/**
+ * Inspect a workflow — show structure without executing
+ * @param {string} filePath
+ */
+async function cmdInspect(filePath) {
+  console.log(`\n🔎 symbiote-node inspect: ${filePath}\n`);
+  const raw = await readFile(resolve(filePath), 'utf-8');
+  const data = JSON.parse(raw);
+
+  console.log(`  Name: ${data.name || '(unnamed)'}`);
+  console.log(`  ID: ${data.id || '(none)'}`);
+  console.log(`  Version: ${data.version || '(none)'}`);
+  console.log();
+
+  // Nodes
+  console.log(`  Nodes (${data.nodes?.length || 0}):`);
+  for (const node of (data.nodes || [])) {
+    const paramKeys = Object.keys(node.params || {});
+    const paramStr = paramKeys.length > 0 ? ` {${paramKeys.join(', ')}}` : '';
+    console.log(`    ${node.id}  [${node.type}]  ${node.name || ''}${paramStr}`);
+  }
+
+  // Connections
+  console.log(`\n  Connections (${data.connections?.length || 0}):`);
+  for (const conn of (data.connections || [])) {
+    console.log(`    ${conn.from}.${conn.out} → ${conn.to}.${conn.in}`);
+  }
+
+  // Execution
+  if (data.execution) {
+    console.log(`\n  Execution: mode=${data.execution.mode}, cache=${data.execution.cache}`);
+  }
+
+  console.log();
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+const HELP = `
+symbiote-node CLI — Universal node-based workflow runner
+Commands:
+  run <file.workflow.json>       Execute a workflow
+  validate <file.workflow.json>  Validate without executing
+  list                           List all registered node types
+  inspect <file.workflow.json>   Show workflow structure
+  serve <file.workflow.json>     Start WebSocket + HTTP server
+
+Options:
+  --pack <name>      Load domain pack (e.g. "custom")  --handlers <dir>   Load handler files from directory
+  --secrets <path>   Path to secrets.json
+  --port <number>    Server port (default: 3100)
+  --verbose          Show detailed execution log
+`;
+
+const { command, target, options } = parseArgs(process.argv);
+
+switch (command) {
+  case 'run':
+    if (!target) { console.error('Usage: symbiote-node run <file.workflow.json>'); process.exit(1); }    await cmdRun(target, options);
+    break;
+
+  case 'validate':
+    if (!target) { console.error('Usage: symbiote-node validate <file.workflow.json>'); process.exit(1); }    await cmdValidate(target, options);
+    break;
+
+  case 'list':
+    await cmdList(options);
+    break;
+
+  case 'inspect':
+    if (!target) { console.error('Usage: symbiote-node inspect <file.workflow.json>'); process.exit(1); }    await cmdInspect(target);
+    break;
+
+  case 'serve': {
+    const port = parseInt(options.port) || 3100;
+    await createServer({
+      port,
+      workflowFile: target,
+      handlersDir: options.handlers ? resolve(options.handlers) : undefined,
+      watchFiles: true,
+      verbose: !!options.verbose,
+    });
+    break;
+  }
+
+  default:
+    console.log(HELP);
+    break;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * symbiote-node - Universal node-based execution engine *
+ * AI-first, domain-agnostic graph runtime.
+ * Zero dependencies, pure ESM.
+ *
+ * @module symbiote-node */
+
+// Core
+export { Graph } from './Graph.js';
+export { Executor } from './Executor.js';
+export { History } from './History.js';
+export { nanoid } from './nanoid.js';
+
+// Registry (AI discovery)
+export {
+  registerNodeType,
+  registerPack,
+  getNodeType,
+  listDrivers,
+  findCompatible,
+  findByCapability,
+  getNodeMenu,
+  registerCustomDrivers,
+  validateParams,
+  listPacks,
+  clearRegistry,
+} from './Registry.js';
+
+// Socket types
+export {
+  registerSocketType,
+  registerSocketTypes,
+  getSocketType,
+  getAllSocketTypes,
+  areSocketsCompatible,
+} from './SocketTypes.js';
+
+// Persistence
+export {
+  serialize,
+  deserialize,
+  saveToFile,
+  loadFromFile,
+} from './Persistence.js';
+
+// Lifecycle
+export { runLifecycle } from './Lifecycle.js';
+
+// Handler loader (Node.js only)
+export { loadHandlers, watchHandlers } from './HandlerLoader.js';
+
+// Agent UI commands
+export * as AgentUI from './AgentUICommands.js';
+
+// Graph server — import directly: import { createServer } from 'symbiote-node/engine/GraphServer.js'
+// Not re-exported here because it requires 'ws' package (optional peer dependency)

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

@@ -0,0 +1,28 @@
+/**
+ * nanoid.js - Minimal ID generator
+ *
+ * Generates short unique IDs (8 chars) for nodes, workflows, etc.
+ * No dependencies. Crypto-based when available, Math.random fallback.
+ *
+ * @module agi-graph/nanoid
+ */
+
+const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+const ID_LENGTH = 8;
+
+/**
+ * Generate a short unique ID
+ * @param {number} [length=8] - ID length
+ * @returns {string}
+ */
+export function nanoid(length = ID_LENGTH) {
+  let id = '';
+  const bytes = typeof globalThis.crypto?.getRandomValues === 'function'
+    ? globalThis.crypto.getRandomValues(new Uint8Array(length))
+    : Array.from({ length }, () => Math.floor(Math.random() * 256));
+
+  for (let i = 0; i < length; i++) {
+    id += ALPHABET[bytes[i] % ALPHABET.length];
+  }
+  return id;
+}

package/vendor/symbiote-node/engine/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "symbiote-node",
+  "version": "0.2.0",
+  "description": "Universal node-based execution engine. Domain-agnostic graph runtime.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "symbiote-node": "./cli.js"  },
+  "exports": {
+    ".": "./index.js",
+    "./cli": "./cli.js",
+    "./packs/*": "./packs/*"
+  },
+  "files": [
+    "*.js",
+    "packs/"
+  ],
+  "keywords": [
+    "graph",
+    "nodes",
+    "workflow",
+    "dag",
+    "automation",
+    "execution-engine"  ],
+  "license": "MIT"
+}