@newsails/veil-studio 1.0.0

package/server/utils/elements/primitive.js

@@ -0,0 +1,36 @@
+'use strict'
+
+module.exports = {
+  type:          'primitive',
+  name:          'Primitive',
+  description:   'Basic drawing primitive: rectangle, circle, line, text-label, or freehand.',
+  icon:          'shapes',
+  defaultWidth:  120,
+  defaultHeight: 80,
+  expansionMode: 'inline',
+  tags:          ['org'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          subtype: element.data.subtype || 'rectangle',
+          color:   element.data.color  || '#3b82f6',
+          fill:    element.data.fill   || 'transparent',
+          label:   element.data.label  || '',
+          points:  element.data.points || [],
+        }
+      },
+      getPorts() { return [] },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/pro-con-list.js

@@ -0,0 +1,39 @@
+'use strict'
+
+module.exports = {
+  type:          'pro-con-list',
+  name:          'Pro / Con List',
+  description:   'Weigh the pros and cons of a decision.',
+  icon:          'scale',
+  defaultWidth:  220,
+  defaultHeight: 130,
+  expansionMode: 'inline',
+  tags:          ['thinking'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          title: element.data.title || '',
+          pros:  element.data.pros  || [],
+          cons:  element.data.cons  || [],
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'items-in',   direction: 'input',  dataType: 'any',  label: 'Items In' },
+          { key: 'summary-out', direction: 'output', dataType: 'text', label: 'Summary Out' },
+        ]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/processor.js

@@ -0,0 +1,54 @@
+'use strict'
+
+module.exports = {
+  type:          'processor',
+  name:          'Processor',
+  description:   'Execute a JavaScript script against input data.',
+  icon:          'terminal',
+  defaultWidth:  220,
+  defaultHeight: 110,
+  expansionMode: 'popup',
+  tags:          ['flow', 'dev'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element, log } = context
+    return {
+      getViewData() {
+        return {
+          script: element.data.script || '',
+          cached: element.data.cached || false,
+          result: element.data.result || null,
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'input-in',  direction: 'input',  dataType: 'any', label: 'Input In' },
+          { key: 'output-out', direction: 'output', dataType: 'any', label: 'Output Out' },
+        ]
+      },
+      actions: {
+        run({ inputs } = {}) {
+          const script = element.data.script
+          if (!script) throw new Error('No script set')
+          let result
+          try {
+            // eslint-disable-next-line no-new-func
+            result = new Function('inputs', script)(inputs)
+          } catch (err) {
+            log(`Script error: ${err.message}`)
+            throw err
+          }
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, result } })
+          return result
+        },
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/project.js

@@ -0,0 +1,40 @@
+'use strict'
+
+module.exports = {
+  type:          'project',
+  name:          'Project',
+  description:   'A project with status and milestones.',
+  icon:          'folder-kanban',
+  defaultWidth:  240,
+  defaultHeight: 130,
+  expansionMode: 'sidebar',
+  tags:          ['pm'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          title:       element.data.title       || '',
+          description: element.data.description || '',
+          status:      element.data.status      || 'active',
+          milestones:  element.data.milestones  || [],
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'tasks-in',   direction: 'input',  dataType: 'any',  label: 'Tasks In' },
+          { key: 'status-out', direction: 'output', dataType: 'text', label: 'Status Out' },
+        ]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/question.js

@@ -0,0 +1,42 @@
+'use strict'
+
+module.exports = {
+  type:          'question',
+  name:          'Question',
+  description:   'An open question with status tracking.',
+  icon:          'help-circle',
+  defaultWidth:  200,
+  defaultHeight: 80,
+  expansionMode: 'inline',
+  tags:          ['research', 'thinking'],
+  isBuiltIn:     true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          text:   element.data.text || '',
+          status: element.data.status || 'open',
+          answer: element.data.answer || null,
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'question-out', direction: 'output', dataType: 'text', label: 'Question Out' },
+          { key: 'answer-out',   direction: 'output', dataType: 'text', label: 'Answer Out' },
+        ]
+      },
+      actions: {
+        answer({ text } = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, status: 'answered', answer: text } })
+        },
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/queue.js

@@ -0,0 +1,85 @@
+'use strict'
+
+module.exports = {
+  type:          'queue',
+  name:          'Queue',
+  description:   'A queue of items with manual or timer-based triggering.',
+  icon:          'list-ordered',
+  defaultWidth:  200,
+  defaultHeight: 110,
+  expansionMode: 'inline',
+  tags:          ['flow'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element, emit, log } = context
+    let _interval = null
+
+    function _startTimer() {
+      if (_interval) return
+      const ms = element.data.intervalMs || 5000
+      _interval = setInterval(() => {
+        const items = element.data.items || []
+        if (items.length === 0) return
+        const [next, ...rest] = items
+        const { updateElement } = require('../board-state.js')
+        updateElement(element.id, { data: { ...element.data, items: rest } })
+        emit('element:view', { id: element.id, viewData: { items: rest, lastDequeued: next } })
+      }, ms)
+    }
+
+    function _stopTimer() {
+      if (_interval) { clearInterval(_interval); _interval = null }
+    }
+
+    if (element.data.triggerType === 'timer') _startTimer()
+
+    return {
+      getViewData() {
+        return {
+          items:       element.data.items       || [],
+          triggerType: element.data.triggerType || 'manual',
+          intervalMs:  element.data.intervalMs  || 5000,
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'item-in',  direction: 'input',  dataType: 'any', label: 'Item In' },
+          { key: 'item-out', direction: 'output', dataType: 'any', label: 'Item Out' },
+        ]
+      },
+      actions: {
+        enqueue({ item } = {}) {
+          const { updateElement } = require('../board-state.js')
+          const items = [...(element.data.items || []), item]
+          updateElement(element.id, { data: { ...element.data, items } })
+        },
+        dequeue(_params) {
+          const items = element.data.items || []
+          if (items.length === 0) return null
+          const [next, ...rest] = items
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, items: rest } })
+          return next
+        },
+        setTimer({ intervalMs, enabled } = {}) {
+          const { updateElement } = require('../board-state.js')
+          if (enabled) {
+            updateElement(element.id, { data: { ...element.data, triggerType: 'timer', intervalMs: intervalMs || 5000 } })
+            _stopTimer()
+            _startTimer()
+          } else {
+            updateElement(element.id, { data: { ...element.data, triggerType: 'manual' } })
+            _stopTimer()
+          }
+        },
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+      onDestroy() { _stopTimer() },
+    }
+  },
+}

package/server/utils/elements/research-note.js

@@ -0,0 +1,41 @@
+'use strict'
+
+module.exports = {
+  type:          'research-note',
+  name:          'Research Note',
+  description:   'A note linked to research sources.',
+  icon:          'notebook',
+  defaultWidth:  220,
+  defaultHeight: 110,
+  expansionMode: 'sidebar',
+  tags:          ['research'],
+  isBuiltIn:     true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          title:     element.data.title   || '',
+          insight:   element.data.insight || '',
+          content:   element.data.content || '',
+          source:    element.data.source  || '',
+          status:    element.data.status  || 'open',
+          sourceIds: element.data.sourceIds || [],
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'sources-in', direction: 'input',  dataType: 'json', label: 'Sources In' },
+          { key: 'note-out',   direction: 'output', dataType: 'text', label: 'Note Out' },
+        ]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/section.js

@@ -0,0 +1,35 @@
+'use strict'
+
+module.exports = {
+  type:          'section',
+  name:          'Section',
+  description:   'A document section with title and content.',
+  icon:          'pilcrow',
+  defaultWidth:  200,
+  defaultHeight: 90,
+  expansionMode: 'inline',
+  tags:          ['docs'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return { title: element.data.title || '', content: element.data.content || '' }
+      },
+      getPorts() {
+        return [
+          { key: 'content-in',  direction: 'input',  dataType: 'text', label: 'Content In' },
+          { key: 'section-out', direction: 'output', dataType: 'text', label: 'Section Out' },
+        ]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/source-collection.js

@@ -0,0 +1,45 @@
+'use strict'
+
+module.exports = {
+  type:          'source-collection',
+  name:          'Source Collection',
+  description:   'A collection of research sources (URLs, files, references).',
+  icon:          'library',
+  defaultWidth:  200,
+  defaultHeight: 110,
+  expansionMode: 'popup',
+  tags:          ['research'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          title:   element.data.title || '',
+          sources: element.data.sources || [],
+        }
+      },
+      getPorts() {
+        return [{ key: 'collection-out', direction: 'output', dataType: 'json', label: 'Collection Out' }]
+      },
+      actions: {
+        addSource({ url, title, type } = {}) {
+          const { updateElement } = require('../board-state.js')
+          const sources = [...(element.data.sources || []), { url, title, type, id: Date.now().toString() }]
+          updateElement(element.id, { data: { ...element.data, sources } })
+        },
+        removeSource({ id } = {}) {
+          const { updateElement } = require('../board-state.js')
+          const sources = (element.data.sources || []).filter(s => s.id !== id)
+          updateElement(element.id, { data: { ...element.data, sources } })
+        },
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/splitter.js

@@ -0,0 +1,42 @@
+'use strict'
+
+module.exports = {
+  type:          'splitter',
+  name:          'Splitter',
+  description:   'Route input to different outputs based on conditions.',
+  icon:          'split',
+  defaultWidth:  200,
+  defaultHeight: 110,
+  expansionMode: 'inline',
+  tags:          ['flow'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return { rules: element.data.rules || [] }
+      },
+      getPorts() {
+        const rules = element.data.rules || []
+        const outPorts = rules.map((r, i) => ({
+          key:       `out-${i}`,
+          direction: 'output',
+          dataType:  'any',
+          label:     r.label || `Out ${i + 1}`,
+        }))
+        return [
+          { key: 'input-in', direction: 'input', dataType: 'any', label: 'Input In' },
+          ...outPorts,
+        ]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/status-update.js

@@ -0,0 +1,38 @@
+'use strict'
+
+module.exports = {
+  type:          'status-update',
+  name:          'Status Update',
+  description:   'A timestamped status update for a project.',
+  icon:          'megaphone',
+  defaultWidth:  220,
+  defaultHeight: 90,
+  expansionMode: 'inline',
+  tags:          ['pm'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          content:   element.data.content   || '',
+          timestamp: element.data.timestamp || null,
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'project-in', direction: 'input',  dataType: 'any',  label: 'Project In' },
+          { key: 'update-out', direction: 'output', dataType: 'text', label: 'Update Out' },
+        ]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/task.js

@@ -0,0 +1,72 @@
+'use strict'
+
+module.exports = {
+  type:          'task',
+  name:          'Task',
+  description:   'Run an agent task and track its status.',
+  icon:          'play-circle',
+  defaultWidth:  220,
+  defaultHeight: 120,
+  expansionMode: 'popup',
+  tags:          ['cli', 'task'],
+  isBuiltIn:     true,
+
+  createInstance(context) {
+    const { element, veil, emit, log } = context
+    let _taskTimeout = null
+
+    return {
+      getViewData() {
+        return {
+          agentName:   element.data.agentName || null,
+          taskId:      element.data.taskId || null,
+          prompt:      element.data.prompt || '',
+          spawnOutput: element.data.spawnOutput || false,
+          result:      element.data.result || null,
+        }
+      },
+
+      getPorts() {
+        return [
+          { key: 'prompt-in', direction: 'input',  dataType: 'text', label: 'Prompt In' },
+          { key: 'data-in',   direction: 'input',  dataType: 'any',  label: 'Data In' },
+          { key: 'result',    direction: 'output', dataType: 'any',  label: 'Result' },
+        ]
+      },
+
+      actions: {
+        async run({ prompt: overridePrompt } = {}) {
+          const agentName = element.data.agentName
+          if (!agentName) throw new Error('No agent name set')
+          const prompt = overridePrompt || element.data.prompt
+          if (!prompt) throw new Error('No prompt set')
+
+          log(`Creating task for agent "${agentName}"`)
+          const task = await veil.post('/tasks', { agent: agentName, prompt })
+
+          const { updateElement, updateElementState } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, taskId: task.id }, state: 'running' })
+          updateElementState(element.id, 'running')
+
+          // Schedule fade-out after 10 min if completed
+          if (_taskTimeout) clearTimeout(_taskTimeout)
+          _taskTimeout = setTimeout(() => {
+            updateElementState(element.id, 'completed')
+          }, 10 * 60 * 1000)
+        },
+
+        async cancel(_params) {
+          const taskId = element.data.taskId
+          if (!taskId) throw new Error('No active task')
+          await veil.post(`/tasks/${encodeURIComponent(taskId)}/cancel`)
+          const { updateElementState } = require('../board-state.js')
+          updateElementState(element.id, 'default')
+        },
+      },
+
+      onDestroy() {
+        if (_taskTimeout) clearTimeout(_taskTimeout)
+      },
+    }
+  },
+}

package/server/utils/elements/template.js

@@ -0,0 +1,46 @@
+'use strict'
+
+module.exports = {
+  type:          'template',
+  name:          'Template',
+  description:   'A text template with variable substitution.',
+  icon:          'file-code',
+  defaultWidth:  220,
+  defaultHeight: 90,
+  expansionMode: 'popup',
+  tags:          ['docs'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          title:     element.data.title || '',
+          template:  element.data.template || '',
+          variables: element.data.variables || [],
+          result:    element.data.result || null,
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'vars-in',    direction: 'input',  dataType: 'json', label: 'Variables In' },
+          { key: 'filled-out', direction: 'output', dataType: 'text', label: 'Filled Out' },
+        ]
+      },
+      actions: {
+        fill({ vars } = {}) {
+          const tmpl = element.data.template || ''
+          const result = tmpl.replace(/\{\{(\w+)\}\}/g, (_, key) => vars?.[key] ?? `{{${key}}}`)
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, result } })
+        },
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}

package/server/utils/elements/test-case.js

@@ -0,0 +1,42 @@
+'use strict'
+
+module.exports = {
+  type:          'test-case',
+  name:          'Test Case',
+  description:   'Track a test case with input, expected, and actual output.',
+  icon:          'flask-conical',
+  defaultWidth:  240,
+  defaultHeight: 120,
+  expansionMode: 'popup',
+  tags:          ['dev'],
+  isBuiltIn:         true,
+  hiddenFromPalette: true,
+
+  createInstance(context) {
+    const { element } = context
+    return {
+      getViewData() {
+        return {
+          title:    element.data.title    || '',
+          input:    element.data.input    || '',
+          expected: element.data.expected || '',
+          actual:   element.data.actual   || null,
+          passed:   element.data.passed   ?? null,
+        }
+      },
+      getPorts() {
+        return [
+          { key: 'input-in',    direction: 'input',  dataType: 'any',  label: 'Input In' },
+          { key: 'expected-in', direction: 'input',  dataType: 'any',  label: 'Expected In' },
+          { key: 'result-out',  direction: 'output', dataType: 'json', label: 'Result Out' },
+        ]
+      },
+      actions: {
+        update(data = {}) {
+          const { updateElement } = require('../board-state.js')
+          updateElement(element.id, { data: { ...element.data, ...data } })
+        },
+      },
+    }
+  },
+}