project-graph-mcp 2.3.2 → 2.4.0

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

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

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

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

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

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

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

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

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

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

@@ -1,60 +0,0 @@
-/**
- * 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 };
-      }
-    },
-  },
-};