@usejarvis/brain 0.1.0

package/src/workflows/auto-suggest.ts

@@ -0,0 +1,290 @@
+/**
+ * Workflow Auto-Suggest — Analyzes M13 awareness patterns to suggest workflows
+ *
+ * Detects:
+ * - Repeated app switches (e.g., copy from browser → paste in editor)
+ * - Recurring errors in the same app
+ * - Regular-interval manual tasks (e.g., checking email every 30 min)
+ * - Repeated tool usage patterns
+ */
+
+import type { NodeRegistry } from './nodes/registry.ts';
+import type { WorkflowDefinition } from './types.ts';
+
+export type WorkflowSuggestion = {
+  id: string;
+  title: string;
+  description: string;
+  confidence: number; // 0-1
+  category: 'repetitive_action' | 'error_response' | 'scheduled_task' | 'app_pattern';
+  previewDefinition: WorkflowDefinition;
+  patternEvidence: string[];
+};
+
+type AwarenessPattern = {
+  type: string;
+  data: Record<string, unknown>;
+  timestamp: number;
+};
+
+export class WorkflowAutoSuggest {
+  private nodeRegistry: NodeRegistry;
+  private llmManager: any;
+  private patterns: AwarenessPattern[] = [];
+  private suggestions: WorkflowSuggestion[] = [];
+  private lastAnalysis = 0;
+  private analysisCooldownMs = 300_000; // 5 min
+
+  constructor(nodeRegistry: NodeRegistry, llmManager: unknown) {
+    this.nodeRegistry = nodeRegistry;
+    this.llmManager = llmManager;
+  }
+
+  /**
+   * Feed awareness events into the pattern buffer
+   */
+  addPattern(event: AwarenessPattern): void {
+    this.patterns.push(event);
+    // Keep last 500 events
+    if (this.patterns.length > 500) {
+      this.patterns = this.patterns.slice(-500);
+    }
+  }
+
+  /**
+   * Generate workflow suggestions from accumulated patterns
+   */
+  async generateSuggestions(): Promise<WorkflowSuggestion[]> {
+    const now = Date.now();
+    // Don't analyze too frequently
+    if (now - this.lastAnalysis < this.analysisCooldownMs && this.suggestions.length > 0) {
+      return this.suggestions;
+    }
+    this.lastAnalysis = now;
+
+    if (this.patterns.length < 10) {
+      return this.suggestions;
+    }
+
+    const detectedPatterns: WorkflowSuggestion[] = [];
+
+    // Detect repeated app switches
+    const appSwitches = this.detectAppSwitchPatterns();
+    detectedPatterns.push(...appSwitches);
+
+    // Detect recurring errors
+    const errorPatterns = this.detectErrorPatterns();
+    detectedPatterns.push(...errorPatterns);
+
+    // Detect scheduled-like behavior
+    const scheduledPatterns = this.detectScheduledPatterns();
+    detectedPatterns.push(...scheduledPatterns);
+
+    // Use LLM for more complex pattern detection if we have enough data
+    if (this.patterns.length > 50) {
+      try {
+        const llmSuggestions = await this.llmAnalyzePatterns();
+        detectedPatterns.push(...llmSuggestions);
+      } catch {
+        // LLM analysis is best-effort
+      }
+    }
+
+    // Deduplicate by title
+    const seen = new Set<string>();
+    this.suggestions = detectedPatterns.filter(s => {
+      if (seen.has(s.title)) return false;
+      seen.add(s.title);
+      return true;
+    }).slice(0, 10);
+
+    return this.suggestions;
+  }
+
+  /**
+   * Dismiss a suggestion
+   */
+  dismiss(id: string): void {
+    this.suggestions = this.suggestions.filter(s => s.id !== id);
+  }
+
+  // ── Pattern detection ──
+
+  private detectAppSwitchPatterns(): WorkflowSuggestion[] {
+    const suggestions: WorkflowSuggestion[] = [];
+    const appSwitchEvents = this.patterns.filter(p => p.type === 'context_change');
+
+    // Look for repeated A→B→A switches (copy-paste patterns)
+    const switchPairs: Map<string, number> = new Map();
+    for (let i = 1; i < appSwitchEvents.length; i++) {
+      const from = String(appSwitchEvents[i - 1]!.data.appName ?? '');
+      const to = String(appSwitchEvents[i]!.data.appName ?? '');
+      if (from && to && from !== to) {
+        const key = `${from}→${to}`;
+        switchPairs.set(key, (switchPairs.get(key) ?? 0) + 1);
+      }
+    }
+
+    for (const [pair, count] of switchPairs) {
+      if (count >= 5) {
+        const [from, to] = pair.split('→');
+        suggestions.push({
+          id: `suggest-switch-${Date.now()}-${from}-${to}`,
+          title: `Automate ${from} → ${to} workflow`,
+          description: `You frequently switch between ${from} and ${to} (${count} times recently). Consider automating this.`,
+          confidence: Math.min(count / 20, 0.9),
+          category: 'app_pattern',
+          patternEvidence: [`${count} switches between ${from} and ${to}`],
+          previewDefinition: {
+            nodes: [
+              { id: 'trigger-1', type: 'trigger.screen', label: `Watch ${from}`, position: { x: 100, y: 200 }, config: { condition_type: 'app_active', app_name: from } },
+              { id: 'action-1', type: 'action.notification', label: `Notify about ${to}`, position: { x: 400, y: 200 }, config: { message: `Ready to switch to ${to}?` } },
+            ],
+            edges: [
+              { id: 'e-1', source: 'trigger-1', target: 'action-1' },
+            ],
+            settings: { maxRetries: 1, retryDelayMs: 5000, timeoutMs: 60000, parallelism: 'sequential', onError: 'stop' },
+          },
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  private detectErrorPatterns(): WorkflowSuggestion[] {
+    const suggestions: WorkflowSuggestion[] = [];
+    const errorEvents = this.patterns.filter(p => p.type === 'error_detected');
+
+    // Group errors by app
+    const errorsByApp: Map<string, number> = new Map();
+    for (const evt of errorEvents) {
+      const app = String(evt.data.appName ?? 'unknown');
+      errorsByApp.set(app, (errorsByApp.get(app) ?? 0) + 1);
+    }
+
+    for (const [app, count] of errorsByApp) {
+      if (count >= 3) {
+        suggestions.push({
+          id: `suggest-error-${Date.now()}-${app}`,
+          title: `Auto-respond to ${app} errors`,
+          description: `${app} has had ${count} errors recently. Set up automatic error handling.`,
+          confidence: Math.min(count / 10, 0.85),
+          category: 'error_response',
+          patternEvidence: [`${count} errors in ${app}`],
+          previewDefinition: {
+            nodes: [
+              { id: 'trigger-1', type: 'trigger.screen', label: `Detect ${app} error`, position: { x: 100, y: 200 }, config: { condition_type: 'text_present', text: 'error' } },
+              { id: 'action-1', type: 'action.agent_task', label: 'Research fix', position: { x: 400, y: 200 }, config: { task: `Research and suggest a fix for the error in ${app}` } },
+              { id: 'action-2', type: 'action.notification', label: 'Notify solution', position: { x: 700, y: 200 }, config: { message: '{{$node["action-1"].data.response}}' } },
+            ],
+            edges: [
+              { id: 'e-1', source: 'trigger-1', target: 'action-1' },
+              { id: 'e-2', source: 'action-1', target: 'action-2' },
+            ],
+            settings: { maxRetries: 2, retryDelayMs: 5000, timeoutMs: 120000, parallelism: 'sequential', onError: 'continue' },
+          },
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  private detectScheduledPatterns(): WorkflowSuggestion[] {
+    const suggestions: WorkflowSuggestion[] = [];
+
+    // Look for events that happen at roughly the same time daily
+    const eventsByHour: Map<number, AwarenessPattern[]> = new Map();
+    for (const p of this.patterns) {
+      const hour = new Date(p.timestamp).getHours();
+      const existing = eventsByHour.get(hour) ?? [];
+      existing.push(p);
+      eventsByHour.set(hour, existing);
+    }
+
+    for (const [hour, events] of eventsByHour) {
+      // Group by type within the hour
+      const typeCount: Map<string, number> = new Map();
+      for (const e of events) {
+        typeCount.set(e.type, (typeCount.get(e.type) ?? 0) + 1);
+      }
+
+      for (const [type, count] of typeCount) {
+        if (count >= 3 && type === 'context_change') {
+          const apps = [...new Set(events.filter(e => e.type === type).map(e => String(e.data.appName ?? '')))].filter(Boolean);
+          if (apps.length > 0) {
+            suggestions.push({
+              id: `suggest-scheduled-${Date.now()}-${hour}`,
+              title: `Schedule ${hour}:00 routine`,
+              description: `You regularly use ${apps.slice(0, 3).join(', ')} around ${hour}:00. Automate this routine.`,
+              confidence: Math.min(count / 10, 0.7),
+              category: 'scheduled_task',
+              patternEvidence: [`${count} occurrences around ${hour}:00`],
+              previewDefinition: {
+                nodes: [
+                  { id: 'trigger-1', type: 'trigger.cron', label: `Daily at ${hour}:00`, position: { x: 100, y: 200 }, config: { expression: `0 ${hour} * * *` } },
+                  { id: 'action-1', type: 'action.notification', label: 'Start routine', position: { x: 400, y: 200 }, config: { message: `Time for your ${hour}:00 routine with ${apps[0]}` } },
+                ],
+                edges: [
+                  { id: 'e-1', source: 'trigger-1', target: 'action-1' },
+                ],
+                settings: { maxRetries: 1, retryDelayMs: 5000, timeoutMs: 60000, parallelism: 'sequential', onError: 'stop' },
+              },
+            });
+          }
+        }
+      }
+    }
+
+    return suggestions;
+  }
+
+  private async llmAnalyzePatterns(): Promise<WorkflowSuggestion[]> {
+    // Summarize recent patterns for LLM analysis
+    const recentPatterns = this.patterns.slice(-100).map(p => ({
+      type: p.type,
+      app: p.data.appName ?? p.data.app ?? undefined,
+      time: new Date(p.timestamp).toLocaleTimeString(),
+    }));
+
+    const prompt = [
+      {
+        role: 'system' as const,
+        content: `You analyze user behavior patterns and suggest automation workflows. Respond with a JSON array of suggestions. Each suggestion should have: title (string), description (string), confidence (0-1), category (repetitive_action|error_response|scheduled_task|app_pattern). Only suggest if you see clear patterns. Return [] if no strong patterns.`,
+      },
+      {
+        role: 'user' as const,
+        content: `Here are recent user activity patterns:\n${JSON.stringify(recentPatterns, null, 2)}\n\nWhat workflow automations would you suggest?`,
+      },
+    ];
+
+    const response = await this.llmManager.chat(prompt, { temperature: 0.3, max_tokens: 2000 });
+    const text = response.content;
+
+    try {
+      const jsonMatch = text.match(/\[[\s\S]*\]/);
+      if (!jsonMatch) return [];
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed)) return [];
+
+      return parsed.slice(0, 3).map((s: any, i: number) => ({
+        id: `suggest-llm-${Date.now()}-${i}`,
+        title: s.title ?? 'Suggested workflow',
+        description: s.description ?? '',
+        confidence: Math.min(s.confidence ?? 0.5, 0.9),
+        category: s.category ?? 'repetitive_action',
+        patternEvidence: ['Detected by AI analysis'],
+        previewDefinition: {
+          nodes: [
+            { id: 'trigger-1', type: 'trigger.manual', label: 'Manual Trigger', position: { x: 100, y: 200 }, config: {} },
+          ],
+          edges: [],
+          settings: { maxRetries: 3, retryDelayMs: 5000, timeoutMs: 300000, parallelism: 'parallel', onError: 'stop' },
+        },
+      }));
+    } catch {
+      return [];
+    }
+  }
+}

package/src/workflows/engine.ts

@@ -0,0 +1,366 @@
+/**
+ * Workflow Engine — Service that orchestrates workflow execution
+ */
+
+import type { Service, ServiceStatus } from '../daemon/services.ts';
+import type { NodeRegistry, ExecutionContext, StepLogger, NodeInput } from './nodes/registry.ts';
+import type { ToolRegistry } from '../actions/tools/registry.ts';
+import type { WorkflowDefinition, WorkflowExecution, ExecutionStatus } from './types.ts';
+import type { WorkflowEvent } from './events.ts';
+import { VariableScope } from './variables.ts';
+import { topologicalSort, getOutgoingEdges, executeNode } from './executor.ts';
+import type { TemplateContext } from './template.ts';
+import * as vault from '../vault/workflows.ts';
+
+export class WorkflowEngine implements Service {
+  name = 'workflow-engine';
+  private _status: ServiceStatus = 'stopped';
+  private nodeRegistry: NodeRegistry;
+  private toolRegistry: ToolRegistry;
+  private llmManager: unknown;
+  private activeExecutions: Map<string, AbortController> = new Map();
+  private eventCallback: ((event: WorkflowEvent) => void) | null = null;
+
+  constructor(
+    nodeRegistry: NodeRegistry,
+    toolRegistry: ToolRegistry,
+    llmManager: unknown,
+  ) {
+    this.nodeRegistry = nodeRegistry;
+    this.toolRegistry = toolRegistry;
+    this.llmManager = llmManager;
+  }
+
+  async start(): Promise<void> {
+    this._status = 'running';
+  }
+
+  async stop(): Promise<void> {
+    // Cancel all active executions
+    for (const [id, controller] of this.activeExecutions) {
+      controller.abort();
+    }
+    this.activeExecutions.clear();
+    this._status = 'stopped';
+  }
+
+  status(): ServiceStatus {
+    return this._status;
+  }
+
+  setEventCallback(cb: (event: WorkflowEvent) => void): void {
+    this.eventCallback = cb;
+  }
+
+  getActiveCount(): number {
+    return this.activeExecutions.size;
+  }
+
+  /**
+   * Execute a workflow by ID.
+   */
+  async execute(
+    workflowId: string,
+    triggerType: string,
+    triggerData?: Record<string, unknown>,
+  ): Promise<WorkflowExecution> {
+    const workflow = vault.getWorkflow(workflowId);
+    if (!workflow) throw new Error(`Workflow '${workflowId}' not found`);
+    if (!workflow.enabled) throw new Error(`Workflow '${workflow.name}' is disabled`);
+
+    const version = vault.getLatestVersion(workflowId);
+    if (!version) throw new Error(`No versions found for workflow '${workflow.name}'`);
+
+    const definition = version.definition;
+
+    // Create execution record
+    const execution = vault.createExecution(workflowId, version.version, triggerType, triggerData);
+
+    this.emit({
+      type: 'execution_started',
+      workflowId,
+      executionId: execution.id,
+      data: { triggerType, triggerData: triggerData ?? {}, workflowName: workflow.name },
+      timestamp: Date.now(),
+    });
+
+    // Run in background (don't block the caller)
+    this.runExecution(execution.id, workflowId, definition, triggerType, triggerData ?? {}).catch(err => {
+      console.error(`[WorkflowEngine] Execution ${execution.id} crashed: ${err.message}`);
+    });
+
+    return execution;
+  }
+
+  /**
+   * Cancel a running execution.
+   */
+  async cancel(executionId: string): Promise<void> {
+    const controller = this.activeExecutions.get(executionId);
+    if (controller) {
+      controller.abort();
+      vault.updateExecution(executionId, { status: 'cancelled', completed_at: Date.now() });
+      this.activeExecutions.delete(executionId);
+
+      const exec = vault.getExecution(executionId);
+      this.emit({
+        type: 'execution_cancelled',
+        workflowId: exec?.workflow_id ?? '',
+        executionId,
+        data: {},
+        timestamp: Date.now(),
+      });
+    }
+  }
+
+  // ── Internal ──
+
+  private async runExecution(
+    executionId: string,
+    workflowId: string,
+    definition: WorkflowDefinition,
+    triggerType: string,
+    triggerData: Record<string, unknown>,
+  ): Promise<void> {
+    const abortController = new AbortController();
+    this.activeExecutions.set(executionId, abortController);
+
+    const startedAt = Date.now();
+    const variables = new VariableScope(workflowId);
+    const nodeMap = new Map(definition.nodes.map(n => [n.id, n]));
+    const nodeOutputs = new Map<string, Record<string, unknown>>();
+
+    // Build template context
+    const templateCtx: TemplateContext = {
+      variables: variables.toObject(),
+      nodeOutputs,
+      triggerData,
+      env: process.env as Record<string, string>,
+    };
+
+    try {
+      // Run graph execution using BFS with routing
+      const levels = topologicalSort(definition);
+
+      // Find trigger node(s) — they already fired, seed their output
+      const triggerNodes = definition.nodes.filter(n => n.type.startsWith('trigger.'));
+      for (const tn of triggerNodes) {
+        nodeOutputs.set(tn.id, { ...triggerData, timestamp: Date.now() });
+        // Also store by label for $node["label"] references
+        nodeOutputs.set(tn.label, { ...triggerData, timestamp: Date.now() });
+      }
+
+      // Track which nodes should be skipped (not on active route)
+      const activeNodes = new Set<string>(triggerNodes.map(n => n.id));
+
+      // Seed: all nodes directly connected from trigger nodes are active
+      for (const tn of triggerNodes) {
+        for (const targetId of getOutgoingEdges(definition, tn.id)) {
+          activeNodes.add(targetId);
+        }
+      }
+
+      for (const level of levels) {
+        if (abortController.signal.aborted) break;
+
+        // Filter to only active nodes at this level
+        const toExecute = level.filter(id => activeNodes.has(id) && !triggerNodes.some(t => t.id === id));
+        if (toExecute.length === 0) continue;
+
+        const settings = definition.settings;
+        const isParallel = settings.parallelism === 'parallel';
+
+        if (isParallel) {
+          await Promise.all(toExecute.map(nodeId => this.executeStep(
+            executionId, workflowId, nodeId, nodeMap, nodeOutputs, variables,
+            templateCtx, definition, abortController, activeNodes,
+          )));
+        } else {
+          for (const nodeId of toExecute) {
+            if (abortController.signal.aborted) break;
+            await this.executeStep(
+              executionId, workflowId, nodeId, nodeMap, nodeOutputs, variables,
+              templateCtx, definition, abortController, activeNodes,
+            );
+          }
+        }
+      }
+
+      // Complete
+      const duration = Date.now() - startedAt;
+      vault.updateExecution(executionId, {
+        status: 'completed',
+        completed_at: Date.now(),
+        duration_ms: duration,
+        variables: variables.toObject(),
+      });
+
+      this.emit({
+        type: 'execution_completed',
+        workflowId,
+        executionId,
+        data: { duration_ms: duration },
+        timestamp: Date.now(),
+      });
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const duration = Date.now() - startedAt;
+
+      vault.updateExecution(executionId, {
+        status: 'failed',
+        error_message: errMsg,
+        completed_at: Date.now(),
+        duration_ms: duration,
+        variables: variables.toObject(),
+      });
+
+      this.emit({
+        type: 'execution_failed',
+        workflowId,
+        executionId,
+        data: { error: errMsg, duration_ms: duration },
+        timestamp: Date.now(),
+      });
+    } finally {
+      this.activeExecutions.delete(executionId);
+    }
+  }
+
+  private async executeStep(
+    executionId: string,
+    workflowId: string,
+    nodeId: string,
+    nodeMap: Map<string, import('./types.ts').WorkflowNode>,
+    nodeOutputs: Map<string, Record<string, unknown>>,
+    variables: VariableScope,
+    templateCtx: TemplateContext,
+    definition: WorkflowDefinition,
+    abortController: AbortController,
+    activeNodes: Set<string>,
+  ): Promise<void> {
+    const node = nodeMap.get(nodeId);
+    if (!node) return;
+
+    const stepResult = vault.createStepResult(executionId, nodeId, node.type);
+    vault.updateStepResult(stepResult.id, { status: 'running', started_at: Date.now() });
+
+    this.emit({
+      type: 'step_started',
+      workflowId,
+      executionId,
+      nodeId,
+      data: { nodeType: node.type, label: node.label },
+      timestamp: Date.now(),
+    });
+
+    // Collect input from incoming edges
+    const incomingEdges = definition.edges.filter(e => e.target === nodeId);
+    const inputData: Record<string, unknown> = {};
+    for (const edge of incomingEdges) {
+      const sourceOutput = nodeOutputs.get(edge.source);
+      if (sourceOutput) Object.assign(inputData, sourceOutput);
+    }
+
+    const input: NodeInput = {
+      data: inputData,
+      variables: variables.toObject(),
+      executionId,
+    };
+
+    const logger: StepLogger = {
+      info: (msg) => console.log(`[Workflow:${nodeId}] ${msg}`),
+      warn: (msg) => console.warn(`[Workflow:${nodeId}] ${msg}`),
+      error: (msg) => console.error(`[Workflow:${nodeId}] ${msg}`),
+    };
+
+    const ctx: ExecutionContext = {
+      executionId,
+      workflowId,
+      toolRegistry: this.toolRegistry,
+      llmManager: this.llmManager,
+      variables,
+      logger,
+      abortSignal: abortController.signal,
+      nodeRegistry: this.nodeRegistry,
+      broadcast: (type, data) => this.emit({
+        type: type as any,
+        workflowId,
+        executionId,
+        data,
+        timestamp: Date.now(),
+      }),
+    };
+
+    // Refresh template context
+    templateCtx.variables = variables.toObject();
+
+    try {
+      const startTime = Date.now();
+      const output = await executeNode(node, input, this.nodeRegistry, ctx, templateCtx, definition.settings);
+      const duration = Date.now() - startTime;
+
+      // Store output
+      nodeOutputs.set(nodeId, output.data);
+      nodeOutputs.set(node.label, output.data); // For $node["label"] references
+
+      vault.updateStepResult(stepResult.id, {
+        status: 'completed',
+        input_data: inputData,
+        output_data: output.data,
+        completed_at: Date.now(),
+        duration_ms: duration,
+      });
+
+      this.emit({
+        type: 'step_completed',
+        workflowId,
+        executionId,
+        nodeId,
+        data: { duration_ms: duration, output: output.data },
+        timestamp: Date.now(),
+      });
+
+      // Activate downstream nodes based on route
+      const targets = getOutgoingEdges(definition, nodeId, output.route);
+      for (const t of targets) {
+        activeNodes.add(t);
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+
+      vault.updateStepResult(stepResult.id, {
+        status: 'failed',
+        input_data: inputData,
+        error_message: errMsg,
+        completed_at: Date.now(),
+        duration_ms: Date.now() - (stepResult.started_at ?? Date.now()),
+      });
+
+      this.emit({
+        type: 'step_failed',
+        workflowId,
+        executionId,
+        nodeId,
+        data: { error: errMsg, nodeType: node.type },
+        timestamp: Date.now(),
+      });
+
+      // Check fallback
+      if (node.fallbackNodeId && nodeMap.has(node.fallbackNodeId)) {
+        logger.info(`Falling back to node: ${node.fallbackNodeId}`);
+        activeNodes.add(node.fallbackNodeId);
+        return;
+      }
+
+      // If onError is 'stop', throw to halt execution
+      if (definition.settings.onError === 'stop') {
+        throw err;
+      }
+      // 'continue' — log and move on
+    }
+  }
+
+  private emit(event: WorkflowEvent): void {
+    this.eventCallback?.(event);
+  }
+}

package/src/workflows/events.ts

@@ -0,0 +1,24 @@
+/**
+ * Workflow Event Types — for real-time WebSocket broadcasting
+ */
+
+export type WorkflowEventType =
+  | 'execution_started'
+  | 'execution_completed'
+  | 'execution_failed'
+  | 'execution_cancelled'
+  | 'step_started'
+  | 'step_completed'
+  | 'step_failed'
+  | 'variable_changed'
+  | 'workflow_enabled'
+  | 'workflow_disabled';
+
+export type WorkflowEvent = {
+  type: WorkflowEventType;
+  workflowId: string;
+  executionId?: string;
+  nodeId?: string;
+  data: Record<string, unknown>;
+  timestamp: number;
+};