project-graph-mcp 2.3.0 → 2.3.2

package/vendor/symbiote-node/engine/packs/debug/inject.handler.js

@@ -0,0 +1,52 @@
+/**
+ * debug/inject — Manual data injection node.
+ *
+ * Provides a textarea for arbitrary JSON data and a Fire button
+ * to push data downstream. Use for testing any part of a workflow
+ * by connecting to the target node's input.
+ *
+ * @module symbiote-node/packs/debug/inject
+ */
+
+export default {
+  type: 'debug/inject',
+  category: 'debug',
+  icon: 'play_circle',
+
+  driver: {
+    description: 'Inject test data — connect to any node input for manual testing',
+    capabilities: ['debug', 'trigger'],
+    inputs: [],
+    outputs: [
+      { name: 'data', type: 'exec' },
+    ],
+    params: {
+      label: { type: 'string', default: 'Test Data', description: 'Display label' },
+      data: { type: 'textarea', default: '{\n  "status": "created",\n  "region": "RU",\n  "smsCount": 100,\n  "clientName": "Test Client"\n}', description: 'JSON payload to inject' },
+    },
+    /** Mark as fireable — UI shows ▶ Fire button */
+    fireable: true,
+  },
+
+  lifecycle: {
+    validate: (inputs, params) => {
+      try {
+        JSON.parse(params.data || '{}');
+        return true;
+      } catch {
+        return false;
+      }
+    },
+
+    async execute(inputs, params) {
+      let payload;
+      try {
+        payload = JSON.parse(params.data || '{}');
+      } catch {
+        return { data: { error: 'Invalid JSON in inject data' } };
+      }
+
+      return { data: payload };
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/flow/agent.handler.js

@@ -0,0 +1,73 @@
+/**
+ * flow/agent — AI Agent trigger node
+ *
+ * Pauses graph execution and invokes an AI agent with prompt + context.
+ * The agent bridge is injected via params.agentBridge or a global registry.
+ * Without a bridge, returns a placeholder indicating agent invocation is needed.
+ *
+ * @module symbiote-node/packs/flow/agent */
+
+export default {
+  type: 'flow/agent',
+  category: 'flow',
+  icon: 'smart_toy',
+
+  driver: {
+    description: 'AI Agent trigger — invoke agent in pipeline',
+    inputs: [
+      { name: 'prompt', type: 'string' },
+      { name: 'context', type: 'any' },
+    ],
+    outputs: [
+      { name: 'result', type: 'any' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      timeout: { type: 'int', default: 30000, description: 'Agent timeout (ms)' },
+      allowedTools: { type: 'array', default: [], description: 'Tools the agent can use' },
+      model: { type: 'string', default: '', description: 'AI model override' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => {
+      if (!inputs.prompt) return false;
+      return true;
+    },
+
+    cacheKey: (inputs) => `agent:${inputs.prompt}:${JSON.stringify(inputs.context)}`,
+
+    execute: async (inputs, params) => {
+      const { prompt, context } = inputs;
+      const { timeout, allowedTools, model } = params;
+
+      // Check if agentBridge is available (injected via params or global)
+      const bridge = params._agentBridge || globalThis.__symbioteNodeAgentBridge;
+      if (!bridge) {
+        // No bridge available — return pending marker
+        return {
+          result: {
+            _agentPending: true,
+            prompt,
+            context,
+            message: 'Agent bridge not connected. Connect via WebSocket (P23) to enable.',
+          },
+          error: null,
+        };
+      }
+
+      try {
+        const response = await Promise.race([
+          bridge.run({ prompt, context, tools: allowedTools, model }),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Agent timeout')), timeout)
+          ),
+        ]);
+
+        return { result: response.data, error: null };
+      } catch (err) {
+        return { result: null, error: err.message };
+      }
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/flow/if.handler.js

@@ -0,0 +1,107 @@
+/**
+ * flow/if — Conditional branching node
+ *
+ * Routes data to 'true' or 'false' output based on condition.
+ * Condition can be a boolean input or a simple expression string.
+ *
+ * @module agi-graph/packs/flow/if
+ */
+
+/**
+ * Evaluate a simple condition expression
+ * Supports: ==, !=, >, <, >=, <=, ===, !==
+ * @param {*} value - Value to test
+ * @param {string} expression - Expression string
+ * @returns {boolean}
+ */
+function evaluateCondition(value, expression) {
+  if (typeof expression === 'boolean') return expression;
+  if (typeof expression === 'string') {
+    const trimmed = expression.trim();
+
+    // Direct boolean strings
+    if (trimmed === 'true') return true;
+    if (trimmed === 'false') return false;
+
+    // Null checks
+    if (trimmed === 'data != null' || trimmed === 'data !== null') return value != null;
+    if (trimmed === 'data == null' || trimmed === 'data === null') return value == null;
+
+    // Comparison operators
+    const match = trimmed.match(/^(.+?)\s*(===|!==|==|!=|>=|<=|>|<)\s*(.+)$/);
+    if (match) {
+      let [, left, op, right] = match;
+      left = left.trim();
+      right = right.trim();
+
+      // Resolve left side
+      const leftVal = left === 'data' || left === 'value' ? value : parseValueLiteral(left);
+      const rightVal = parseValueLiteral(right);
+
+      switch (op) {
+        case '===': return leftVal === rightVal;
+        case '!==': return leftVal !== rightVal;
+        case '==': return leftVal == rightVal;
+        case '!=': return leftVal != rightVal;
+        case '>': return leftVal > rightVal;
+        case '<': return leftVal < rightVal;
+        case '>=': return leftVal >= rightVal;
+        case '<=': return leftVal <= rightVal;
+      }
+    }
+  }
+
+  // Fallback: truthy check
+  return !!value;
+}
+
+/**
+ * Parse a literal value from condition string
+ * @param {string} str
+ * @returns {*}
+ */
+function parseValueLiteral(str) {
+  if (str === 'null') return null;
+  if (str === 'undefined') return undefined;
+  if (str === 'true') return true;
+  if (str === 'false') return false;
+  if (str.startsWith("'") && str.endsWith("'")) return str.slice(1, -1);
+  if (str.startsWith('"') && str.endsWith('"')) return str.slice(1, -1);
+  const num = Number(str);
+  if (!isNaN(num)) return num;
+  return str;
+}
+
+export default {
+  type: 'flow/if',
+  category: 'flow',
+  icon: 'call_split',
+
+  driver: {
+    description: 'Conditional branch — routes data by condition',
+    inputs: [
+      { name: 'condition', type: 'any' },
+      { name: 'data', type: 'any' },
+    ],
+    outputs: [
+      { name: 'true', type: 'any' },
+      { name: 'false', type: 'any' },
+    ],
+    params: {
+      expression: { type: 'string', default: '', description: 'Condition expression (optional, overrides condition input)' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => inputs.data !== undefined,
+    execute: (inputs, params) => {
+      const condValue = params.expression
+        ? evaluateCondition(inputs.data, params.expression)
+        : !!inputs.condition;
+
+      return condValue
+        ? { true: inputs.data, false: null }
+        : { true: null, false: inputs.data };
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/flow/loop.handler.js

@@ -0,0 +1,58 @@
+/**
+ * flow/loop — Iteration node
+ *
+ * Iterates over an array, executing a body function for each item.
+ * The bodyType param specifies which registered node type to execute per item.
+ *
+ * @module agi-graph/packs/flow/loop
+ */
+
+import { getNodeType } from '../../Registry.js';
+
+export default {
+  type: 'flow/loop',
+  category: 'flow',
+  icon: 'loop',
+
+  driver: {
+    description: 'Iterate over array — execute body per item',
+    inputs: [
+      { name: 'items', type: 'array' },
+    ],
+    outputs: [
+      { name: 'results', type: 'array' },
+    ],
+    params: {
+      bodyType: { type: 'string', default: '', description: 'Node type to execute per item' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => Array.isArray(inputs.items),
+    execute: async (inputs, params) => {
+      const { items } = inputs;
+      const { bodyType } = params;
+      const results = [];
+
+      if (!bodyType) {
+        // No body type: return items as-is
+        return { results: items };
+      }
+
+      const typeDef = getNodeType(bodyType);
+      const executeFn = typeDef?.lifecycle?.execute || typeDef?.process;
+
+      if (!executeFn) {
+        return { results: items };
+      }
+
+      for (let i = 0; i < items.length; i++) {
+        const itemInput = { value: items[i], index: i, total: items.length };
+        const itemResult = await executeFn(itemInput, params);
+        results.push(itemResult);
+      }
+
+      return { results };
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/flow/merge.handler.js

@@ -0,0 +1,60 @@
+/**
+ * flow/merge — Multi-input data merge node
+ *
+ * Combines data from multiple inputs (a, b) into a single output.
+ * Supports three modes:
+ *   - 'first' (default): returns first non-null input (branch merge after IF)
+ *   - 'combine': Object.assign all non-null inputs (deep merge)
+ *   - 'append': collect all non-null inputs into an array
+ *
+ * @module symbiote-node/packs/flow/merge
+ */
+
+export default {
+  type: 'flow/merge',
+  category: 'flow',
+  icon: 'merge',
+
+  driver: {
+    description: 'Merge branches — combine data from multiple inputs',
+    inputs: [
+      { name: 'a', type: 'any' },
+      { name: 'b', type: 'any' },
+    ],
+    outputs: [
+      { name: 'data', type: 'any' },
+    ],
+    params: {
+      mode: {
+        type: 'string',
+        default: 'first',
+        description: 'first = first non-null, combine = Object.assign, append = array',
+      },
+    },
+  },
+
+  lifecycle: {
+    execute: (inputs, params) => {
+      const mode = params?.mode || 'first';
+
+      if (mode === 'combine') {
+        const merged = {};
+        for (const value of Object.values(inputs)) {
+          if (value != null && typeof value === 'object') {
+            Object.assign(merged, value);
+          }
+        }
+        return { data: merged };
+      }
+
+      if (mode === 'append') {
+        const items = Object.values(inputs).filter(v => v != null);
+        return { data: items };
+      }
+
+      // Default: 'first' — first non-null input
+      const data = inputs.a != null ? inputs.a : inputs.b;
+      return { data };
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/flow/retry.handler.js

@@ -0,0 +1,65 @@
+/**
+ * flow/retry — Retry on error node
+ *
+ * If input has an error, re-invokes the action up to maxRetries times.
+ * Passes through successful results immediately.
+ *
+ * @module agi-graph/packs/flow/retry
+ */
+
+export default {
+  type: 'flow/retry',
+  category: 'flow',
+  icon: 'refresh',
+
+  driver: {
+    description: 'Retry action on error — up to N attempts',
+    inputs: [
+      { name: 'action', type: 'any' },
+      { name: 'error', type: 'any' },
+    ],
+    outputs: [
+      { name: 'result', type: 'any' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      maxRetries: { type: 'int', default: 3, description: 'Maximum retry attempts' },
+      delay: { type: 'int', default: 1000, description: 'Delay between retries (ms)' },
+    },
+  },
+
+  lifecycle: {
+    execute: async (inputs, params) => {
+      // If no error, pass through the action result
+      if (inputs.error == null && inputs.action != null) {
+        return { result: inputs.action, error: null };
+      }
+
+      // If error but no actionFn to retry, propagate error
+      if (inputs.action?._retryFn) {
+        const { maxRetries, delay } = params;
+        let lastError = inputs.error;
+
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+          if (delay > 0 && attempt > 1) {
+            await new Promise(r => setTimeout(r, delay));
+          }
+          try {
+            const result = await inputs.action._retryFn();
+            return { result, error: null };
+          } catch (err) {
+            lastError = err.message;
+          }
+        }
+
+        return { result: null, error: `Failed after ${maxRetries} retries: ${lastError}` };
+      }
+
+      // No retry function available, pass through with error
+      return {
+        result: inputs.action,
+        error: inputs.error ? String(inputs.error) : null,
+      };
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/flow/switch.handler.js

@@ -0,0 +1,64 @@
+/**
+ * flow/switch — Multi-branch routing node
+ *
+ * Routes data to one of N case outputs based on value match.
+ * Falls back to 'default' output if no case matches.
+ *
+ * @module agi-graph/packs/flow/switch
+ */
+
+export default {
+  type: 'flow/switch',
+  category: 'flow',
+  icon: 'alt_route',
+
+  driver: {
+    description: 'Multi-branch routing by value match',
+    inputs: [
+      { name: 'value', type: 'any' },
+      { name: 'data', type: 'any' },
+    ],
+    outputs: [
+      { name: 'default', type: 'any' },
+    ],
+    params: {
+      cases: { type: 'object', default: {}, description: 'Map of value → output name' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => inputs.data !== undefined,
+    execute: (inputs, params) => {
+      const { data } = inputs;
+      // Auto-extract value from data[field] when no explicit value input
+      const value = inputs.value !== undefined
+        ? inputs.value
+        : (params.field && data ? data[params.field] : undefined);
+      const cases = params.cases;
+      const hasCases = cases && Object.keys(cases).length > 0;
+      const result = { default: null };
+
+      if (hasCases) {
+        // Explicit cases mode: value → mapped output name
+        for (const outputName of Object.values(cases)) {
+          result[outputName] = null;
+        }
+        const stringValue = String(value);
+        const matchedOutput = cases[stringValue];
+        if (matchedOutput) {
+          result[matchedOutput] = data;
+          result.dynamicOutputs = Object.values(cases);
+        } else {
+          result.default = data;
+        }
+      } else {
+        // Direct routing: value IS the output name (e.g. 'created' → output 'created')
+        const outputName = String(value);
+        result[outputName] = data;
+        result.dynamicOutputs = [outputName];
+      }
+
+      return result;
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/flow/wait-all.handler.js

@@ -0,0 +1,39 @@
+/**
+ * flow/wait-all — Barrier node
+ *
+ * Waits for all non-null inputs and merges them into a single object.
+ * Acts as a synchronization point for parallel branches.
+ *
+ * @module agi-graph/packs/flow/wait-all
+ */
+
+export default {
+  type: 'flow/wait-all',
+  category: 'flow',
+  icon: 'join',
+
+  driver: {
+    description: 'Barrier — merge all inputs into one object',
+    inputs: [
+      { name: 'a', type: 'any' },
+      { name: 'b', type: 'any' },
+      { name: 'c', type: 'any' },
+    ],
+    outputs: [
+      { name: 'output', type: 'object' },
+    ],
+    params: {},
+  },
+
+  lifecycle: {
+    execute: (inputs) => {
+      const output = {};
+      for (const [key, val] of Object.entries(inputs)) {
+        if (val != null) {
+          output[key] = val;
+        }
+      }
+      return { output };
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/io/http-request.handler.js

@@ -0,0 +1,82 @@
+/**
+ * io/http-request — Universal HTTP client node
+ *
+ * Performs HTTP requests using native fetch API.
+ * Supports GET, POST, PUT, DELETE with configurable headers and timeout.
+ *
+ * @module agi-graph/packs/io/http-request
+ */
+
+export default {
+  type: 'io/http-request',
+  category: 'io',
+  icon: 'http',
+
+  driver: {
+    description: 'HTTP request (fetch) — GET, POST, PUT, DELETE',
+    inputs: [
+      { name: 'url', type: 'string' },
+      { name: 'body', type: 'any' },
+    ],
+    outputs: [
+      { name: 'response', type: 'any' },
+      { name: 'status', type: 'number' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      method: { type: 'string', default: 'GET', description: 'HTTP method' },
+      headers: { type: 'object', default: {}, description: 'Request headers' },
+      timeout: { type: 'int', default: 30000, description: 'Timeout (ms)' },
+      responseType: { type: 'string', default: 'auto', description: 'json | text | auto' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => {
+      if (!inputs.url) return false;
+      return true;
+    },
+
+    cacheKey: (inputs, params) =>
+      `http:${params.method}:${inputs.url}:${JSON.stringify(inputs.body)}`,
+
+    execute: async (inputs, params) => {
+      const { url, body } = inputs;
+      const { method, headers, timeout, responseType } = params;
+
+      try {
+        const fetchOptions = {
+          method: method || 'GET',
+          headers: { ...headers },
+          signal: AbortSignal.timeout(timeout),
+        };
+
+        if (body && method !== 'GET' && method !== 'HEAD') {
+          if (typeof body === 'object') {
+            fetchOptions.body = JSON.stringify(body);
+            fetchOptions.headers['Content-Type'] =
+              fetchOptions.headers['Content-Type'] || 'application/json';
+          } else {
+            fetchOptions.body = String(body);
+          }
+        }
+
+        const res = await fetch(url, fetchOptions);
+
+        let response;
+        const contentType = res.headers.get('content-type') || '';
+
+        if (responseType === 'json' || (responseType === 'auto' && contentType.includes('json'))) {
+          response = await res.json();
+        } else {
+          response = await res.text();
+        }
+
+        return { response, status: res.status, error: null };
+
+      } catch (err) {
+        return { response: null, status: 0, error: err.message };
+      }
+    },
+  },
+};

package/vendor/symbiote-node/engine/packs/io/read-file.handler.js

@@ -0,0 +1,60 @@
+/**
+ * io/read-file — Read file contents
+ *
+ * Reads a file from disk. Auto-parses JSON files.
+ *
+ * @module agi-graph/packs/io/read-file
+ */
+
+import { promises as fs } from 'fs';
+
+export default {
+  type: 'io/read-file',
+  category: 'io',
+  icon: 'file_open',
+
+  driver: {
+    description: 'Read file from disk (auto-parses JSON)',
+    inputs: [
+      { name: 'path', type: 'string' },
+    ],
+    outputs: [
+      { name: 'content', type: 'string' },
+      { name: 'parsed', type: 'any' },
+      { name: 'error', type: 'string' },
+    ],
+    params: {
+      encoding: { type: 'string', default: 'utf8', description: 'File encoding' },
+    },
+  },
+
+  lifecycle: {
+    validate: (inputs) => {
+      if (!inputs.path) return false;
+      return true;
+    },
+
+    // No caching — file content may change
+    cacheKey: null,
+
+    execute: async (inputs, params) => {
+      try {
+        const content = await fs.readFile(inputs.path, params.encoding || 'utf8');
+
+        let parsed = null;
+        if (inputs.path.endsWith('.json')) {
+          try {
+            parsed = JSON.parse(content);
+          } catch {
+            // Not valid JSON
+          }
+        }
+
+        return { content, parsed, error: null };
+
+      } catch (err) {
+        return { content: null, parsed: null, error: err.message };
+      }
+    },
+  },
+};