@usejarvis/brain 0.1.0

package/src/workflows/nodes/logic/variable-get.ts

@@ -0,0 +1,37 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const variableGetNode: NodeDefinition = {
+  type: 'logic.variable_get',
+  label: 'Get Variable',
+  description: 'Read a workflow variable and inject it into the data stream.',
+  category: 'logic',
+  icon: '📖',
+  color: '#f59e0b',
+  configSchema: {
+    key: {
+      type: 'string',
+      label: 'Key',
+      description: 'Variable name to read.',
+      required: true,
+      placeholder: 'my_variable',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const key = String(config.key ?? '');
+    if (!key) throw new Error('key is required');
+
+    const value = ctx.variables.get(key);
+    ctx.logger.info(`Getting variable "${key}": ${JSON.stringify(value)?.slice(0, 80)}`);
+
+    return {
+      data: {
+        ...input.data,
+        [key]: value,
+        variable_key: key,
+        variable_value: value,
+      },
+    };
+  },
+};

package/src/workflows/nodes/logic/variable-set.ts

@@ -0,0 +1,59 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const variableSetNode: NodeDefinition = {
+  type: 'logic.variable_set',
+  label: 'Set Variable',
+  description: 'Set a workflow variable (in-memory or persistent across executions).',
+  category: 'logic',
+  icon: '📝',
+  color: '#f59e0b',
+  configSchema: {
+    key: {
+      type: 'string',
+      label: 'Key',
+      description: 'Variable name to set.',
+      required: true,
+      placeholder: 'my_variable',
+    },
+    value: {
+      type: 'template',
+      label: 'Value',
+      description: 'Value to assign. Supports template expressions.',
+      required: true,
+      placeholder: '{{data.result}}',
+    },
+    persistent: {
+      type: 'boolean',
+      label: 'Persistent',
+      description: 'If true, the variable persists across workflow executions.',
+      required: false,
+      default: false,
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const key = String(config.key ?? '');
+    if (!key) throw new Error('key is required');
+
+    const value = config.value;
+    const persistent = config.persistent === true;
+
+    ctx.logger.info(`Setting variable "${key}" (persistent=${persistent})`);
+
+    if (persistent) {
+      ctx.variables.setPersistent(key, value);
+    } else {
+      ctx.variables.set(key, value);
+    }
+
+    return {
+      data: {
+        ...input.data,
+        variable_key: key,
+        variable_value: value,
+        persistent,
+      },
+    };
+  },
+};

package/src/workflows/nodes/registry.ts

@@ -0,0 +1,99 @@
+/**
+ * Node Registry — mirrors ToolRegistry pattern
+ */
+
+import type { NodeCategory, NodeConfigField } from '../types.ts';
+import type { ToolRegistry } from '../../actions/tools/registry.ts';
+
+// ── Node I/O ──
+
+export type NodeInput = {
+  data: Record<string, unknown>;
+  variables: Record<string, unknown>;
+  executionId: string;
+};
+
+export type NodeOutput = {
+  data: Record<string, unknown>;
+  route?: string;   // For conditional nodes: which handle to follow
+};
+
+// ── Execution Context ──
+
+export type StepLogger = {
+  info(msg: string): void;
+  warn(msg: string): void;
+  error(msg: string): void;
+};
+
+export type ExecutionContext = {
+  executionId: string;
+  workflowId: string;
+  toolRegistry: ToolRegistry;
+  llmManager: unknown;      // LLMManager — loosely typed to avoid circular deps
+  variables: VariableScopeInterface;
+  logger: StepLogger;
+  abortSignal: AbortSignal;
+  nodeRegistry?: NodeRegistry;  // For self-heal: re-execute with corrected config
+  /** Broadcast a message to dashboard chat (used by send_message, notification nodes) */
+  broadcast?: (type: string, data: Record<string, unknown>) => void;
+};
+
+export interface VariableScopeInterface {
+  get(key: string): unknown;
+  set(key: string, value: unknown): void;
+  setPersistent(key: string, value: unknown): void;
+  toObject(): Record<string, unknown>;
+}
+
+// ── Node Definition ──
+
+export type NodeDefinition = {
+  type: string;                                    // e.g., 'trigger.cron'
+  label: string;
+  description: string;
+  category: NodeCategory;
+  icon: string;
+  color: string;
+  configSchema: Record<string, NodeConfigField>;
+  inputs: string[];
+  outputs: string[];
+  execute: (input: NodeInput, config: Record<string, unknown>, ctx: ExecutionContext) => Promise<NodeOutput>;
+};
+
+// ── Registry ──
+
+export class NodeRegistry {
+  private nodes: Map<string, NodeDefinition> = new Map();
+
+  register(node: NodeDefinition): void {
+    if (this.nodes.has(node.type)) {
+      throw new Error(`Node type '${node.type}' is already registered`);
+    }
+    this.nodes.set(node.type, node);
+  }
+
+  get(type: string): NodeDefinition | undefined {
+    return this.nodes.get(type);
+  }
+
+  list(category?: NodeCategory): NodeDefinition[] {
+    const all = Array.from(this.nodes.values());
+    if (!category) return all;
+    return all.filter(n => n.category === category);
+  }
+
+  has(type: string): boolean {
+    return this.nodes.has(type);
+  }
+
+  getCategories(): NodeCategory[] {
+    const cats = new Set<NodeCategory>();
+    for (const n of this.nodes.values()) cats.add(n.category);
+    return Array.from(cats);
+  }
+
+  count(): number {
+    return this.nodes.size;
+  }
+}

package/src/workflows/nodes/transform/aggregate.ts

@@ -0,0 +1,99 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const aggregateTransform: NodeDefinition = {
+  type: 'transform.aggregate',
+  label: 'Aggregate',
+  description: 'Compute sum, average, count, min, or max over an array field.',
+  category: 'transform',
+  icon: '🔢',
+  color: '#10b981',
+  configSchema: {
+    operation: {
+      type: 'select',
+      label: 'Operation',
+      description: 'Aggregation operation to apply.',
+      required: true,
+      default: 'sum',
+      options: [
+        { label: 'Sum', value: 'sum' },
+        { label: 'Average', value: 'avg' },
+        { label: 'Count', value: 'count' },
+        { label: 'Min', value: 'min' },
+        { label: 'Max', value: 'max' },
+      ],
+    },
+    field: {
+      type: 'string',
+      label: 'Field',
+      description: 'Dot-path to the array field in data. For sum/avg/min/max, each element or sub-field is used as a number.',
+      required: true,
+      placeholder: 'items',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const operation = String(config.operation ?? 'sum');
+    const field = String(config.field ?? '');
+
+    if (!field) throw new Error('field is required');
+
+    // Resolve dot-path to get the array
+    const parts = field.split('.');
+    let arr: unknown = input.data as unknown;
+    for (const part of parts) {
+      if (arr && typeof arr === 'object') arr = (arr as Record<string, unknown>)[part];
+      else { arr = undefined; break; }
+    }
+
+    ctx.logger.info(`Aggregate: ${operation} on field "${field}"`);
+
+    if (operation === 'count') {
+      const count = Array.isArray(arr) ? arr.length : (arr !== undefined && arr !== null ? 1 : 0);
+      return { data: { ...input.data, aggregate_result: count, aggregate_operation: 'count' } };
+    }
+
+    if (!Array.isArray(arr)) {
+      throw new Error(`Field "${field}" must be an array for ${operation}`);
+    }
+
+    const numbers = arr.map(item => {
+      if (typeof item === 'number') return item;
+      if (typeof item === 'string') return parseFloat(item);
+      if (item !== null && typeof item === 'object') {
+        // If field path has sub-field like "items.value", the last segment after the array is handled here
+        // For simple arrays of numbers this branch is fine
+        const numVal = Object.values(item as Record<string, unknown>)[0];
+        return typeof numVal === 'number' ? numVal : parseFloat(String(numVal));
+      }
+      return NaN;
+    }).filter(n => !isNaN(n));
+
+    let result: number;
+    switch (operation) {
+      case 'sum':
+        result = numbers.reduce((a, b) => a + b, 0);
+        break;
+      case 'avg':
+        result = numbers.length > 0 ? numbers.reduce((a, b) => a + b, 0) / numbers.length : 0;
+        break;
+      case 'min':
+        result = numbers.length > 0 ? Math.min(...numbers) : 0;
+        break;
+      case 'max':
+        result = numbers.length > 0 ? Math.max(...numbers) : 0;
+        break;
+      default:
+        throw new Error(`Unknown operation: ${operation}`);
+    }
+
+    return {
+      data: {
+        ...input.data,
+        aggregate_result: result,
+        aggregate_operation: operation,
+        aggregate_count: numbers.length,
+      },
+    };
+  },
+};

package/src/workflows/nodes/transform/csv-parse.ts

@@ -0,0 +1,70 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const csvParseTransform: NodeDefinition = {
+  type: 'transform.csv_parse',
+  label: 'CSV Parse',
+  description: 'Parse a CSV string into an array of row objects.',
+  category: 'transform',
+  icon: '📊',
+  color: '#10b981',
+  configSchema: {
+    input_field: {
+      type: 'string',
+      label: 'Input Field',
+      description: 'Dot-path to the field in data containing the CSV string.',
+      required: true,
+      placeholder: 'csv_content',
+    },
+    delimiter: {
+      type: 'string',
+      label: 'Delimiter',
+      description: 'Column delimiter character.',
+      required: false,
+      default: ',',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const inputField = String(config.input_field ?? '');
+    const delimiter = String(config.delimiter ?? ',');
+
+    if (!inputField) throw new Error('input_field is required');
+
+    // Resolve dot-path
+    const raw = inputField.split('.').reduce<unknown>((acc, key) => {
+      if (acc && typeof acc === 'object') return (acc as Record<string, unknown>)[key];
+      return undefined;
+    }, input.data as unknown);
+
+    if (typeof raw !== 'string') {
+      throw new Error(`Field "${inputField}" must be a string, got ${typeof raw}`);
+    }
+
+    ctx.logger.info(`CSV parse: field "${inputField}", delimiter "${delimiter}"`);
+
+    const lines = raw.split('\n').map(l => l.trim()).filter(l => l.length > 0);
+    if (lines.length === 0) {
+      return { data: { ...input.data, csv_rows: [], csv_headers: [] } };
+    }
+
+    const headers = lines[0]!.split(delimiter).map(h => h.trim().replace(/^"|"$/g, ''));
+    const rows: Record<string, string>[] = [];
+
+    for (let i = 1; i < lines.length; i++) {
+      const values = lines[i]!.split(delimiter).map(v => v.trim().replace(/^"|"$/g, ''));
+      const row: Record<string, string> = {};
+      headers.forEach((h, idx) => { row[h] = values[idx] ?? ''; });
+      rows.push(row);
+    }
+
+    return {
+      data: {
+        ...input.data,
+        csv_rows: rows,
+        csv_headers: headers,
+        csv_count: rows.length,
+      },
+    };
+  },
+};

package/src/workflows/nodes/transform/json-parse.ts

@@ -0,0 +1,63 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const jsonParseTransform: NodeDefinition = {
+  type: 'transform.json_parse',
+  label: 'JSON Parse',
+  description: 'Parse a JSON string field and store the result under a new key.',
+  category: 'transform',
+  icon: '{ }',
+  color: '#10b981',
+  configSchema: {
+    input_field: {
+      type: 'string',
+      label: 'Input Field',
+      description: 'Dot-path to the field in data containing the JSON string.',
+      required: true,
+      placeholder: 'body',
+    },
+    output_field: {
+      type: 'string',
+      label: 'Output Field',
+      description: 'Key to store the parsed result under in the output data.',
+      required: true,
+      placeholder: 'parsed',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const inputField = String(config.input_field ?? '');
+    const outputField = String(config.output_field ?? 'parsed');
+
+    if (!inputField) throw new Error('input_field is required');
+
+    // Resolve dot-path
+    const raw = inputField.split('.').reduce<unknown>((acc, key) => {
+      if (acc && typeof acc === 'object') return (acc as Record<string, unknown>)[key];
+      return undefined;
+    }, input.data as unknown);
+
+    ctx.logger.info(`JSON parse: field "${inputField}" → "${outputField}"`);
+
+    let parsed: unknown;
+    if (typeof raw === 'string') {
+      try {
+        parsed = JSON.parse(raw);
+      } catch (err) {
+        throw new Error(`Failed to parse JSON in field "${inputField}": ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } else if (raw !== undefined && raw !== null) {
+      // Already an object — pass through
+      parsed = raw;
+    } else {
+      throw new Error(`Field "${inputField}" is undefined or null`);
+    }
+
+    return {
+      data: {
+        ...input.data,
+        [outputField]: parsed,
+      },
+    };
+  },
+};

package/src/workflows/nodes/transform/map-filter.ts

@@ -0,0 +1,84 @@
+import type { NodeDefinition } from '../registry.ts';
+import { safeEvaluateExpression } from '../../safe-eval.ts';
+
+export const mapFilterTransform: NodeDefinition = {
+  type: 'transform.map_filter',
+  label: 'Map / Filter',
+  description: 'Map or filter an array using a JavaScript expression.',
+  category: 'transform',
+  icon: '🗂️',
+  color: '#10b981',
+  configSchema: {
+    items_field: {
+      type: 'string',
+      label: 'Items Field',
+      description: 'Dot-path to the array field in data to transform.',
+      required: true,
+      placeholder: 'items',
+    },
+    expression: {
+      type: 'template',
+      label: 'Expression',
+      description: 'JavaScript expression applied to each element. `item` is the current element, `index` is its position. For map: return transformed value. For filter: return truthy/falsy.',
+      required: true,
+      placeholder: 'item.value > 10',
+    },
+    mode: {
+      type: 'select',
+      label: 'Mode',
+      description: 'Whether to transform (map) or filter the array.',
+      required: true,
+      default: 'filter',
+      options: [
+        { label: 'Map', value: 'map' },
+        { label: 'Filter', value: 'filter' },
+      ],
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const itemsField = String(config.items_field ?? '');
+    const expression = String(config.expression ?? '');
+    const mode = String(config.mode ?? 'filter');
+
+    if (!itemsField) throw new Error('items_field is required');
+    if (!expression) throw new Error('expression is required');
+
+    // Resolve dot-path
+    const parts = itemsField.split('.');
+    let arr: unknown = input.data as unknown;
+    for (const part of parts) {
+      if (arr && typeof arr === 'object') arr = (arr as Record<string, unknown>)[part];
+      else { arr = undefined; break; }
+    }
+
+    if (!Array.isArray(arr)) {
+      throw new Error(`Field "${itemsField}" must be an array, got ${typeof arr}`);
+    }
+
+    ctx.logger.info(`${mode} on field "${itemsField}" (${arr.length} items)`);
+
+    let result: unknown[];
+    if (mode === 'map') {
+      result = arr.map((item, index) => {
+        try { return safeEvaluateExpression(expression, { item, index, data: input.data }); }
+        catch (e) { ctx.logger.warn(`map expression error at index ${index}: ${e}`); return item; }
+      });
+    } else {
+      result = arr.filter((item, index) => {
+        try { return !!safeEvaluateExpression(expression, { item, index, data: input.data }); }
+        catch (e) { ctx.logger.warn(`filter expression error at index ${index}: ${e}`); return false; }
+      });
+    }
+
+    return {
+      data: {
+        ...input.data,
+        [itemsField.split('.').pop() ?? 'result']: result,
+        transform_count: result.length,
+        transform_mode: mode,
+      },
+    };
+  },
+};

package/src/workflows/nodes/transform/regex-match.ts

@@ -0,0 +1,89 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const regexMatchTransform: NodeDefinition = {
+  type: 'transform.regex_match',
+  label: 'Regex Match',
+  description: 'Apply a regular expression to a string field and capture matches.',
+  category: 'transform',
+  icon: '🔍',
+  color: '#10b981',
+  configSchema: {
+    input_field: {
+      type: 'string',
+      label: 'Input Field',
+      description: 'Dot-path to the field in data to run the regex against.',
+      required: true,
+      placeholder: 'body',
+    },
+    pattern: {
+      type: 'string',
+      label: 'Pattern',
+      description: 'Regular expression pattern (without slashes).',
+      required: true,
+      placeholder: '\\d+',
+    },
+    flags: {
+      type: 'string',
+      label: 'Flags',
+      description: 'Regex flags (e.g., "gi", "m"). Defaults to "g".',
+      required: false,
+      default: 'g',
+    },
+  },
+  inputs: ['default'],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const inputField = String(config.input_field ?? '');
+    const pattern = String(config.pattern ?? '');
+    const flags = String(config.flags ?? 'g');
+
+    if (!inputField) throw new Error('input_field is required');
+    if (!pattern) throw new Error('pattern is required');
+
+    // Resolve dot-path
+    const raw = inputField.split('.').reduce<unknown>((acc, key) => {
+      if (acc && typeof acc === 'object') return (acc as Record<string, unknown>)[key];
+      return undefined;
+    }, input.data as unknown);
+
+    if (typeof raw !== 'string') {
+      throw new Error(`Field "${inputField}" must be a string, got ${typeof raw}`);
+    }
+
+    ctx.logger.info(`Regex match: /${pattern}/${flags} on field "${inputField}"`);
+
+    let regex: RegExp;
+    try {
+      regex = new RegExp(pattern, flags);
+    } catch (err) {
+      throw new Error(`Invalid regex pattern: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    const matches: string[] = [];
+    const groups: Array<Record<string, string | undefined>> = [];
+
+    if (flags.includes('g')) {
+      let match: RegExpExecArray | null;
+      while ((match = regex.exec(raw)) !== null) {
+        matches.push(match[0]);
+        if (match.groups) groups.push(match.groups);
+      }
+    } else {
+      const match = regex.exec(raw);
+      if (match) {
+        matches.push(match[0]);
+        if (match.groups) groups.push(match.groups);
+      }
+    }
+
+    return {
+      data: {
+        ...input.data,
+        regex_matches: matches,
+        regex_groups: groups,
+        regex_count: matches.length,
+        regex_matched: matches.length > 0,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/calendar.ts

@@ -0,0 +1,33 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const calendarTrigger: NodeDefinition = {
+  type: 'trigger.calendar',
+  label: 'Calendar Trigger',
+  description: 'Fire a set number of minutes before a calendar event starts.',
+  category: 'trigger',
+  icon: '📅',
+  color: '#8b5cf6',
+  configSchema: {
+    minutes_before: {
+      type: 'number',
+      label: 'Minutes Before',
+      description: 'How many minutes before the event to fire.',
+      required: true,
+      default: 15,
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    const minutesBefore = typeof config.minutes_before === 'number' ? config.minutes_before : 15;
+    ctx.logger.info(`Calendar trigger fired — ${minutesBefore} minutes before event`);
+    return {
+      data: {
+        triggerType: 'calendar',
+        minutes_before: minutesBefore,
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};

package/src/workflows/nodes/triggers/clipboard.ts

@@ -0,0 +1,32 @@
+import type { NodeDefinition } from '../registry.ts';
+
+export const clipboardTrigger: NodeDefinition = {
+  type: 'trigger.clipboard',
+  label: 'Clipboard Trigger',
+  description: 'Fire when clipboard content changes, optionally filtering by regex pattern.',
+  category: 'trigger',
+  icon: '📋',
+  color: '#8b5cf6',
+  configSchema: {
+    pattern: {
+      type: 'string',
+      label: 'Pattern Filter',
+      description: 'Optional regex pattern. Only fire if clipboard text matches.',
+      required: false,
+      placeholder: 'https?://',
+    },
+  },
+  inputs: [],
+  outputs: ['default'],
+  execute: async (input, config, ctx) => {
+    ctx.logger.info('Clipboard trigger fired');
+    return {
+      data: {
+        triggerType: 'clipboard',
+        pattern: config.pattern ?? null,
+        firedAt: Date.now(),
+        ...input.data,
+      },
+    };
+  },
+};