devglide 0.1.1

package/src/apps/workflow/public/models/node-types.js

@@ -0,0 +1,300 @@
+// ── Workflow Editor — Node Type Registry ────────────────────────────────
+// Defines all 12 node types with config fields, icons, colors, and defaults.
+// Config field schemas mirror the TypeScript interfaces in types.ts.
+
+export const NODE_CATEGORIES = [
+  { id: 'triggers', label: 'Triggers', color: '#f59e0b' },
+  { id: 'actions',  label: 'Actions',  color: '#6366f1' },
+  { id: 'control',  label: 'Control Flow', color: '#ec4899' },
+  { id: 'steps',    label: 'Steps',    color: '#64748b' },
+];
+
+export const NODE_TYPES = {
+  // ── Triggers ────────────────────────────────────────────────────────────
+  'trigger': {
+    label: 'Trigger',
+    category: 'triggers',
+    icon: '\u26A1',
+    color: '#f59e0b',
+    ports: { in: 0, out: 1 },
+    configFields: [
+      { key: 'triggerType', label: 'Trigger Type', type: 'select',
+        options: ['manual', 'prompt', 'voice', 'webhook', 'schedule', 'git-event', 'log-pattern', 'kanban-move'] },
+      { key: 'cron', label: 'Cron Expression', type: 'text',
+        showWhen: { triggerType: 'schedule' } },
+      { key: 'gitEvent', label: 'Git Event', type: 'select',
+        options: ['commit', 'push', 'branch-create', 'tag'],
+        showWhen: { triggerType: 'git-event' } },
+      { key: 'gitBranch', label: 'Branch Filter', type: 'text',
+        showWhen: { triggerType: 'git-event' } },
+      { key: 'logPattern', label: 'Log Pattern (regex)', type: 'text',
+        showWhen: { triggerType: 'log-pattern' } },
+      { key: 'kanbanTargetColumn', label: 'Target Column', type: 'text',
+        showWhen: { triggerType: 'kanban-move' } },
+    ],
+    defaultConfig: { nodeType: 'trigger', triggerType: 'manual' },
+  },
+
+  // ── Actions ─────────────────────────────────────────────────────────────
+  'action:shell': {
+    label: 'Shell',
+    category: 'actions',
+    icon: '\u{1F4BB}',
+    color: '#22c55e',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'command', label: 'Command', type: 'textarea' },
+      { key: 'cwd', label: 'Working Directory', type: 'text' },
+      { key: 'captureOutput', label: 'Capture Output', type: 'checkbox' },
+      { key: 'outputVariable', label: 'Output Variable', type: 'text' },
+    ],
+    defaultConfig: { nodeType: 'action:shell', command: '', captureOutput: true },
+  },
+
+  'action:kanban': {
+    label: 'Kanban',
+    category: 'actions',
+    icon: '\u{1F4CB}',
+    color: '#3b82f6',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'operation', label: 'Operation', type: 'select',
+        options: ['create', 'move', 'update', 'append-work-log', 'append-review', 'list'] },
+      { key: 'featureId', label: 'Feature ID', type: 'text' },
+      { key: 'itemId', label: 'Item ID', type: 'text' },
+      { key: 'columnName', label: 'Column Name', type: 'text',
+        showWhen: { operation: 'move' } },
+      { key: 'title', label: 'Title', type: 'text',
+        showWhen: { operation: 'create' } },
+      { key: 'description', label: 'Description', type: 'textarea',
+        showWhen: { operation: 'create' } },
+      { key: 'content', label: 'Content', type: 'textarea' },
+    ],
+    defaultConfig: { nodeType: 'action:kanban', operation: 'create' },
+  },
+
+  'action:git': {
+    label: 'Git',
+    category: 'actions',
+    icon: '\u{1F500}',
+    color: '#f97316',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'operation', label: 'Operation', type: 'select',
+        options: ['status', 'diff', 'commit', 'push', 'branch-create', 'checkout', 'add'] },
+      { key: 'message', label: 'Commit Message', type: 'text',
+        showWhen: { operation: 'commit' } },
+      { key: 'branch', label: 'Branch', type: 'text' },
+      { key: 'files', label: 'Files (one per line)', type: 'textarea' },
+    ],
+    defaultConfig: { nodeType: 'action:git', operation: 'status' },
+  },
+
+  'action:llm': {
+    label: 'LLM',
+    category: 'actions',
+    icon: '\u{1F9E0}',
+    color: '#8b5cf6',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'promptSource', label: 'Prompt Source', type: 'select',
+        options: ['inline', 'file'] },
+      { key: 'prompt', label: 'Prompt', type: 'textarea',
+        showWhen: { promptSource: 'inline' } },
+      { key: 'promptFile', label: 'Prompt File', type: 'text',
+        showWhen: { promptSource: 'file' } },
+      { key: 'model', label: 'Model', type: 'text' },
+      { key: 'temperature', label: 'Temperature', type: 'number' },
+      { key: 'maxTokens', label: 'Max Tokens', type: 'number' },
+    ],
+    defaultConfig: { nodeType: 'action:llm', promptSource: 'inline', prompt: '' },
+  },
+
+  'action:test': {
+    label: 'Test',
+    category: 'actions',
+    icon: '\u{1F9EA}',
+    color: '#06b6d4',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'operation', label: 'Operation', type: 'select',
+        options: ['run-scenario', 'run-saved', 'save-scenario', 'list-saved'] },
+      { key: 'scenarioId', label: 'Scenario ID', type: 'text' },
+      { key: 'target', label: 'Target URL', type: 'text',
+        showWhen: { operation: 'run-scenario' } },
+      { key: 'linkedItemId', label: 'Linked Item ID', type: 'text' },
+    ],
+    defaultConfig: { nodeType: 'action:test', operation: 'run-saved' },
+  },
+
+  'action:log': {
+    label: 'Log',
+    category: 'actions',
+    icon: '\u{1F4DD}',
+    color: '#64748b',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'operation', label: 'Operation', type: 'select',
+        options: ['write', 'read', 'clear'] },
+      { key: 'targetPath', label: 'Target Path', type: 'text' },
+      { key: 'type', label: 'Log Type', type: 'text',
+        showWhen: { operation: 'write' } },
+      { key: 'message', label: 'Message', type: 'textarea',
+        showWhen: { operation: 'write' } },
+      { key: 'lines', label: 'Lines to Read', type: 'number',
+        showWhen: { operation: 'read' } },
+    ],
+    defaultConfig: { nodeType: 'action:log', operation: 'write' },
+  },
+
+  'action:file': {
+    label: 'File',
+    category: 'actions',
+    icon: '\u{1F4C1}',
+    color: '#14b8a6',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'operation', label: 'Operation', type: 'select',
+        options: ['read', 'write', 'append', 'exists', 'tree'] },
+      { key: 'path', label: 'Path', type: 'text' },
+      { key: 'content', label: 'Content', type: 'textarea',
+        showWhen: { operation: 'write' } },
+    ],
+    defaultConfig: { nodeType: 'action:file', operation: 'read', path: '' },
+  },
+
+  'action:http': {
+    label: 'HTTP',
+    category: 'actions',
+    icon: '\u{1F310}',
+    color: '#e11d48',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'method', label: 'Method', type: 'select',
+        options: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] },
+      { key: 'url', label: 'URL', type: 'text' },
+      { key: 'headers', label: 'Headers (JSON)', type: 'textarea' },
+      { key: 'body', label: 'Body', type: 'textarea' },
+    ],
+    defaultConfig: { nodeType: 'action:http', method: 'GET', url: '' },
+  },
+
+  // ── Control Flow ────────────────────────────────────────────────────────
+  'decision': {
+    label: 'Decision',
+    category: 'control',
+    icon: '\u{1F500}',
+    color: '#ec4899',
+    ports: { in: 1, out: 'dynamic' },
+    configFields: [
+      { key: 'conditionType', label: 'Condition Type', type: 'select',
+        options: ['exit-code', 'variable', 'expression'] },
+      { key: 'variable', label: 'Variable', type: 'text',
+        showWhen: { conditionType: 'variable' } },
+      { key: 'expression', label: 'Expression', type: 'text',
+        showWhen: { conditionType: 'expression' } },
+    ],
+    defaultConfig: { nodeType: 'decision', conditionType: 'expression', ports: [] },
+  },
+
+  'loop': {
+    label: 'Loop',
+    category: 'control',
+    icon: '\u{1F504}',
+    color: '#d946ef',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'loopType', label: 'Loop Type', type: 'select',
+        options: ['count', 'while', 'for-each'] },
+      { key: 'count', label: 'Count', type: 'number',
+        showWhen: { loopType: 'count' } },
+      { key: 'condition', label: 'Condition', type: 'text',
+        showWhen: { loopType: 'while' } },
+      { key: 'collection', label: 'Collection Variable', type: 'text',
+        showWhen: { loopType: 'for-each' } },
+      { key: 'itemVariable', label: 'Item Variable', type: 'text',
+        showWhen: { loopType: 'for-each' } },
+      { key: 'maxIterations', label: 'Max Iterations', type: 'number' },
+    ],
+    defaultConfig: { nodeType: 'loop', loopType: 'count', count: 1 },
+  },
+
+  'sub-workflow': {
+    label: 'Sub-Workflow',
+    category: 'control',
+    icon: '\u{1F4E6}',
+    color: '#a855f7',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'workflowId', label: 'Workflow ID', type: 'text' },
+    ],
+    defaultConfig: { nodeType: 'sub-workflow', workflowId: '' },
+  },
+
+  // ── Steps (backward compat) ─────────────────────────────────────────────
+  'step': {
+    label: 'Step',
+    category: 'steps',
+    icon: '\u{1F4CB}',
+    color: '#64748b',
+    ports: { in: 1, out: 1 },
+    configFields: [
+      { key: 'instructions', label: 'Instructions', type: 'textarea' },
+      { key: 'instructionFile', label: 'Instruction File (.md)', type: 'text' },
+    ],
+    defaultConfig: { nodeType: 'step', instructions: '', instructionFile: '' },
+  },
+};
+
+/**
+ * Get the node type definition for a given type key.
+ * @param {string} type
+ * @returns {object|null}
+ */
+export function getNodeType(type) {
+  return NODE_TYPES[type] ?? null;
+}
+
+/**
+ * Get all node types within a category.
+ * @param {string} categoryId
+ * @returns {Array<[string, object]>}
+ */
+export function getNodesByCategory(categoryId) {
+  return Object.entries(NODE_TYPES).filter(([, def]) => def.category === categoryId);
+}
+
+/**
+ * Resolve the concrete output ports for a node.
+ * For static ports (out: N), returns N port descriptors with ids 'out-0', 'out-1', ...
+ * For dynamic ports (decision nodes), reads config.ports array.
+ * Always returns at least one output port.
+ * @param {object} node - { type, config }
+ * @returns {Array<{ id: string, label: string }>}
+ */
+export function resolveOutputPorts(node) {
+  const typeDef = NODE_TYPES[node.type];
+  const portsDef = typeDef?.ports?.out ?? 1;
+
+  if (portsDef === 'dynamic') {
+    const configPorts = node.config?.ports;
+    if (Array.isArray(configPorts) && configPorts.length > 0) {
+      return configPorts.map(p => ({ id: p.id, label: p.label ?? p.id }));
+    }
+    // Fallback: single default output so the node is still connectable
+    return [{ id: 'out-0', label: 'default' }];
+  }
+
+  const count = typeof portsDef === 'number' ? portsDef : 1;
+  return Array.from({ length: count }, (_, i) => ({ id: `out-${i}`, label: `out-${i}` }));
+}
+
+/**
+ * Resolve the number of input ports for a node.
+ * @param {object} node - { type }
+ * @returns {number}
+ */
+export function resolveInputPortCount(node) {
+  const typeDef = NODE_TYPES[node.type];
+  return typeDef?.ports?.in ?? 1;
+}

package/src/apps/workflow/public/models/workflow-model.js

@@ -0,0 +1,257 @@
+// ── Workflow Editor — Graph Data Model ──────────────────────────────────
+// Manages the workflow graph: nodes, edges, and structural queries.
+
+import { store } from '../state/store.js';
+import { NODE_TYPES } from './node-types.js';
+
+function uid() {
+  return crypto.randomUUID();
+}
+
+function markDirty() {
+  store.set('isDirty', true);
+}
+
+function emitWorkflow() {
+  // Re-set to trigger listeners even though the reference may be the same
+  store.set('workflow', store.get('workflow'));
+}
+
+export const WorkflowModel = {
+  /**
+   * Load a workflow object into the store.
+   * @param {object} workflow - { id, name, description, nodes, edges, ... }
+   */
+  load(workflow) {
+    const wf = {
+      id: workflow.id,
+      name: workflow.name ?? 'Untitled Workflow',
+      description: workflow.description ?? '',
+      nodes: (workflow.nodes ?? []).map(n => ({ ...n })),
+      edges: (workflow.edges ?? []).map(e => ({ ...e })),
+      enabled: workflow.enabled ?? true,
+      global: workflow.global ?? false,
+      createdAt: workflow.createdAt ?? new Date().toISOString(),
+      updatedAt: workflow.updatedAt ?? new Date().toISOString(),
+    };
+    store.set('workflow', wf);
+    store.set('isDirty', false);
+    store.set('selectedNodeIds', new Set());
+    store.set('selectedEdgeIds', new Set());
+  },
+
+  /**
+   * Return a serializable workflow object from the current store state.
+   * @returns {object|null}
+   */
+  save() {
+    const wf = store.get('workflow');
+    if (!wf) return null;
+    return {
+      id: wf.id,
+      name: wf.name,
+      description: wf.description,
+      enabled: wf.enabled,
+      global: wf.global,
+      nodes: wf.nodes.map(n => ({ ...n, position: { ...n.position }, config: { ...n.config } })),
+      edges: wf.edges.map(e => ({ ...e })),
+      createdAt: wf.createdAt,
+      updatedAt: new Date().toISOString(),
+    };
+  },
+
+  /**
+   * Add a node to the workflow.
+   * @param {string} type - Node type key (e.g. 'action:shell')
+   * @param {string} label - Display label
+   * @param {{ x: number, y: number }} position
+   * @param {object} [config={}] - Node-specific config
+   * @returns {object} The created node
+   */
+  addNode(type, label, position, config = {}) {
+    const wf = store.get('workflow');
+    if (!wf) return null;
+
+    const typeDef = NODE_TYPES[type];
+    const node = {
+      id: uid(),
+      type,
+      label: label || typeDef?.label || type,
+      position: { x: position.x, y: position.y },
+      config: { ...(typeDef?.defaultConfig ?? {}), ...config },
+    };
+    wf.nodes.push(node);
+    markDirty();
+    emitWorkflow();
+    return node;
+  },
+
+  /**
+   * Remove a node and all connected edges.
+   * @param {string} id
+   */
+  removeNode(id) {
+    const wf = store.get('workflow');
+    if (!wf) return;
+
+    wf.nodes = wf.nodes.filter(n => n.id !== id);
+    wf.edges = wf.edges.filter(e => e.source !== id && e.target !== id);
+
+    // Remove from selection
+    const sel = store.get('selectedNodeIds');
+    if (sel.has(id)) {
+      sel.delete(id);
+      store.set('selectedNodeIds', new Set(sel));
+    }
+
+    markDirty();
+    emitWorkflow();
+  },
+
+  /**
+   * Partial-update a node.
+   * @param {string} id
+   * @param {object} updates - Merged into the node
+   */
+  updateNode(id, updates) {
+    const wf = store.get('workflow');
+    if (!wf) return;
+    const node = wf.nodes.find(n => n.id === id);
+    if (!node) return;
+
+    if (updates.config) {
+      node.config = { ...node.config, ...updates.config };
+      delete updates.config;
+    }
+    Object.assign(node, updates);
+    markDirty();
+    emitWorkflow();
+  },
+
+  /**
+   * Move a node to a new position.
+   * @param {string} id
+   * @param {number} x
+   * @param {number} y
+   */
+  moveNode(id, x, y) {
+    const wf = store.get('workflow');
+    if (!wf) return;
+    const node = wf.nodes.find(n => n.id === id);
+    if (!node) return;
+    node.position = { x, y };
+    markDirty();
+    emitWorkflow();
+  },
+
+  /**
+   * Add an edge between two nodes.
+   * @param {string} source - Source node ID
+   * @param {string} target - Target node ID
+   * @param {string} [sourcePort] - Port identifier (for multi-output nodes)
+   * @param {string} [condition] - Edge label / condition text
+   * @returns {object} The created edge
+   */
+  addEdge(source, target, sourcePort, condition) {
+    const wf = store.get('workflow');
+    if (!wf) return null;
+
+    // Prevent duplicate edges
+    const exists = wf.edges.some(
+      e => e.source === source && e.target === target && (e.sourcePort ?? '') === (sourcePort ?? '')
+    );
+    if (exists) return null;
+
+    // Prevent self-loops
+    if (source === target) return null;
+
+    const edge = {
+      id: uid(),
+      source,
+      target,
+      sourcePort: sourcePort ?? null,
+      condition: condition ?? null,
+    };
+    wf.edges.push(edge);
+    markDirty();
+    emitWorkflow();
+    return edge;
+  },
+
+  /**
+   * Remove an edge.
+   * @param {string} id
+   */
+  removeEdge(id) {
+    const wf = store.get('workflow');
+    if (!wf) return;
+    wf.edges = wf.edges.filter(e => e.id !== id);
+
+    const sel = store.get('selectedEdgeIds');
+    if (sel.has(id)) {
+      sel.delete(id);
+      store.set('selectedEdgeIds', new Set(sel));
+    }
+
+    markDirty();
+    emitWorkflow();
+  },
+
+  /**
+   * Get a node by ID.
+   * @param {string} id
+   * @returns {object|null}
+   */
+  getNode(id) {
+    const wf = store.get('workflow');
+    return wf?.nodes.find(n => n.id === id) ?? null;
+  },
+
+  /**
+   * Get an edge by ID.
+   * @param {string} id
+   * @returns {object|null}
+   */
+  getEdge(id) {
+    const wf = store.get('workflow');
+    return wf?.edges.find(e => e.id === id) ?? null;
+  },
+
+  /**
+   * Get all nodes of a given type.
+   * @param {string} type
+   * @returns {Array<object>}
+   */
+  getNodesOfType(type) {
+    const wf = store.get('workflow');
+    return wf?.nodes.filter(n => n.type === type) ?? [];
+  },
+
+  /**
+   * Get all edges targeting a given node.
+   * @param {string} nodeId
+   * @returns {Array<object>}
+   */
+  getIncomingEdges(nodeId) {
+    const wf = store.get('workflow');
+    return wf?.edges.filter(e => e.target === nodeId) ?? [];
+  },
+
+  /**
+   * Get all edges originating from a given node.
+   * @param {string} nodeId
+   * @returns {Array<object>}
+   */
+  getOutgoingEdges(nodeId) {
+    const wf = store.get('workflow');
+    return wf?.edges.filter(e => e.source === nodeId) ?? [];
+  },
+
+  /**
+   * Serialize the workflow as a plain JSON-friendly object.
+   * @returns {object|null}
+   */
+  toJSON() {
+    return this.save();
+  },
+};