@geenius/ai-workflow 0.1.0

package/packages/shared/src/validators.ts

@@ -0,0 +1,215 @@
+// @geenius-ai-workflow/shared — src/validators.ts
+/**
+ * Zod schemas for workflow definition and run validation.
+ */
+import { z } from 'zod/v4'
+
+// ============================================================================
+// Step Config Schemas
+// ============================================================================
+
+export const llmCallConfigSchema = z.object({
+  type: z.literal('llm-call'),
+  model: z.string().optional(),
+  systemPrompt: z.string().min(1, 'System prompt is required'),
+  userPromptTemplate: z.string().min(1, 'User prompt template is required'),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional(),
+  parseJson: z.boolean().optional(),
+  outputVar: z.string().min(1, 'Output variable name is required'),
+})
+
+export const transformConfigSchema = z.object({
+  type: z.literal('transform'),
+  expression: z.string().min(1, 'Expression is required'),
+  inputVars: z.array(z.string()).min(1, 'At least one input variable is required'),
+  outputVar: z.string().min(1),
+})
+
+export const conditionConfigSchema = z.object({
+  type: z.literal('condition'),
+  expression: z.string().min(1),
+  trueStepId: z.string().min(1),
+  falseStepId: z.string().min(1),
+})
+
+export const humanApprovalConfigSchema = z.object({
+  type: z.literal('human-approval'),
+  message: z.string().min(1, 'Approval message is required'),
+  approvers: z.array(z.string()).optional(),
+  autoApproveAfterMs: z.number().positive().optional(),
+})
+
+export const webhookConfigSchema = z.object({
+  type: z.literal('webhook'),
+  url: z.string().url('Valid URL required'),
+  method: z.enum(['GET', 'POST', 'PUT', 'DELETE']),
+  headers: z.record(z.string()).optional(),
+  bodyTemplate: z.string().optional(),
+  outputVar: z.string().min(1),
+})
+
+export const delayConfigSchema = z.object({
+  type: z.literal('delay'),
+  durationMs: z.number().int().positive('Duration must be positive'),
+})
+
+export const parallelConfigSchema = z.object({
+  type: z.literal('parallel'),
+  stepIds: z.array(z.string()).min(2, 'Parallel needs at least 2 steps'),
+  failurePolicy: z.enum(['fail-fast', 'continue']),
+})
+
+export const loopConfigSchema = z.object({
+  type: z.literal('loop'),
+  stepIds: z.array(z.string()).min(1),
+  iterateVar: z.string().min(1),
+  itemVar: z.string().min(1),
+  maxIterations: z.number().int().positive().optional(),
+})
+
+export const subWorkflowConfigSchema = z.object({
+  type: z.literal('sub-workflow'),
+  workflowId: z.string().min(1),
+  inputMapping: z.record(z.string()),
+  outputVar: z.string().min(1),
+})
+
+export const customStepConfigSchema = z.object({
+  type: z.literal('custom'),
+  handler: z.string().min(1, 'Handler name is required'),
+  params: z.record(z.unknown()),
+  outputVar: z.string().optional(),
+})
+
+export const stepConfigSchema = z.discriminatedUnion('type', [
+  llmCallConfigSchema,
+  transformConfigSchema,
+  conditionConfigSchema,
+  humanApprovalConfigSchema,
+  webhookConfigSchema,
+  delayConfigSchema,
+  parallelConfigSchema,
+  loopConfigSchema,
+  subWorkflowConfigSchema,
+  customStepConfigSchema,
+])
+
+// ============================================================================
+// Step Definition Schema
+// ============================================================================
+
+export const workflowStepDefSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1, 'Step name is required'),
+  type: z.enum(['llm-call', 'transform', 'condition', 'human-approval', 'webhook', 'delay', 'parallel', 'loop', 'sub-workflow', 'custom']),
+  config: stepConfigSchema,
+  position: z.object({ x: z.number(), y: z.number() }).optional(),
+  optional: z.boolean().optional(),
+  retries: z.object({ maxAttempts: z.number().int().positive(), backoffMs: z.number().positive() }).optional(),
+})
+
+// ============================================================================
+// Connection Schema
+// ============================================================================
+
+export const stepConnectionSchema = z.object({
+  fromStepId: z.string().min(1),
+  toStepId: z.string().min(1),
+  label: z.string().optional(),
+  condition: z.string().optional(),
+})
+
+// ============================================================================
+// Variable Schema
+// ============================================================================
+
+export const workflowVariableSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(['string', 'number', 'boolean', 'object', 'array']),
+  description: z.string().optional(),
+  required: z.boolean().optional(),
+  default: z.unknown().optional(),
+})
+
+// ============================================================================
+// Workflow Definition Schema
+// ============================================================================
+
+export const workflowDefinitionSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1, 'Workflow name is required').max(120, 'Name too long'),
+  description: z.string().max(2000).optional(),
+  version: z.number().int().positive(),
+  status: z.enum(['draft', 'active', 'paused', 'archived']),
+  steps: z.array(workflowStepDefSchema).min(1, 'At least one step is required'),
+  connections: z.array(stepConnectionSchema),
+  inputSchema: z.array(workflowVariableSchema).optional(),
+  variables: z.record(z.unknown()).optional(),
+  tags: z.array(z.string()).optional(),
+  createdBy: z.string(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+})
+
+// ============================================================================
+// Run Schema
+// ============================================================================
+
+export const stepResultSchema = z.object({
+  stepId: z.string(),
+  stepName: z.string(),
+  type: z.enum(['llm-call', 'transform', 'condition', 'human-approval', 'webhook', 'delay', 'parallel', 'loop', 'sub-workflow', 'custom']),
+  status: z.enum(['pending', 'running', 'completed', 'failed', 'skipped', 'waiting-approval']),
+  input: z.record(z.unknown()).optional(),
+  output: z.unknown().optional(),
+  error: z.string().optional(),
+  durationMs: z.number(),
+  tokens: z.number().optional(),
+  costUsd: z.number().optional(),
+  startedAt: z.number(),
+  completedAt: z.number().optional(),
+})
+
+export const workflowRunSchema = z.object({
+  id: z.string(),
+  workflowId: z.string(),
+  workflowVersion: z.number(),
+  status: z.enum(['pending', 'running', 'paused', 'completed', 'failed', 'cancelled']),
+  input: z.record(z.unknown()),
+  variables: z.record(z.unknown()),
+  stepResults: z.array(stepResultSchema),
+  currentStepIndex: z.number(),
+  error: z.string().optional(),
+  triggeredBy: z.string(),
+  startedAt: z.number(),
+  completedAt: z.number().optional(),
+})
+
+// ============================================================================
+// Validation helpers
+// ============================================================================
+
+/** Validate a WorkflowDefinition, returning { success, data?, error? } */
+export function validateWorkflow(data: unknown) {
+  return workflowDefinitionSchema.safeParse(data)
+}
+
+/** Validate a WorkflowRun, returning { success, data?, error? } */
+export function validateRun(data: unknown) {
+  return workflowRunSchema.safeParse(data)
+}
+
+/** Validate step connections reference valid step IDs */
+export function validateConnectionIntegrity(
+  steps: Array<{ id: string }>,
+  connections: Array<{ fromStepId: string; toStepId: string }>,
+): string[] {
+  const stepIds = new Set(steps.map(s => s.id))
+  const errors: string[] = []
+  for (const conn of connections) {
+    if (!stepIds.has(conn.fromStepId)) errors.push(`Connection references unknown source step: ${conn.fromStepId}`)
+    if (!stepIds.has(conn.toStepId)) errors.push(`Connection references unknown target step: ${conn.toStepId}`)
+  }
+  return errors
+}

package/packages/shared/tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"ES2022","module":"ESNext","moduleResolution":"bundler","declaration":true,"declarationMap":true,"sourceMap":true,"outDir":"./dist","rootDir":"./src","strict":true,"esModuleInterop":true,"skipLibCheck":true,"forceConsistentCasingInFileNames":true,"resolveJsonModule":true,"isolatedModules":true},"include":["src"],"exclude":["node_modules","dist"]}

package/packages/shared/tsup.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from 'tsup'
+export default defineConfig({
+    entry: { index: 'src/index.ts', engine: 'src/engine.ts', steps: 'src/steps.ts', 'convex/index': 'src/convex/index.ts' },
+    format: ['esm'], dts: true, clean: true, sourcemap: true,
+})

package/packages/shared/vitest.config.ts

@@ -0,0 +1,4 @@
+import { defineConfig } from 'vitest/config'
+export default defineConfig({
+  test: { globals: true, environment: 'node' },
+})

package/packages/solidjs/README.md

@@ -0,0 +1 @@
+# ✦ @geenius-ai-workflow/solidjs\n\n> Geenius AI Workflow — SolidJS primitives & components\n\n---\n\n## Overview\nBuilt with Steve Jobs-level minimalism and Jony Ive-level craftsmanship, this package is designed to deliver unparalleled developer experience (DX) and rock-solid performance.\n\n## Installation\n\n```bash\npnpm add @geenius-ai-workflow/solidjs\n```\n\n## Usage\n\n```typescript\nimport { init } from '@geenius-ai-workflow/solidjs';\n\n// Initialize the module with absolute precision\ninit({\n  mode: 'premium',\n});\n```\n\n## Architecture\n- **Zero-config**: It just works.\n- **Strictly Typed**: Fully written in TypeScript for flawless IntelliSense.\n- **Framework Agnostic**: seamlessly integrates into the Geenius ecosystem.\n\n---\n\n*Designed by Antigravity HQ*\n

package/packages/solidjs/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@geenius-ai-workflow/solidjs",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Geenius AI Workflow \u2014 SolidJS primitives & components",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm clean && pnpm build"
+  },
+  "dependencies": {
+    "@geenius-ai-workflow/shared": "workspace:*"
+  },
+  "devDependencies": {
+    "solid-js": "^1.9.0",
+    "tsup": "^8.5.1",
+    "typescript": "~5.9.3"
+  },
+  "peerDependencies": {
+    "solid-js": ">=1.8.0"
+  },
+  "author": "Antigravity HQ",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/solidjs/src/components/ApprovalModal.tsx

@@ -0,0 +1,18 @@
+// @geenius-ai-workflow/solidjs — components/ApprovalModal.tsx
+import { Show, For } from 'solid-js'
+import type { ApprovalRequest } from '../primitives/createApprovalGate'
+
+export function ApprovalModal(props: { request: ApprovalRequest | null; onApprove: (id: string) => void; onReject: (id: string) => void }) {
+  return (
+    <Show when={props.request}>{(req) => (
+      <div data-workflow="approval-modal" role="dialog" aria-modal="true">
+        <div data-workflow="approval-overlay" />
+        <div data-workflow="approval-dialog">
+          <div data-workflow="approval-header"><span data-workflow="approval-icon">👤</span><h3 data-workflow="approval-title">Approval Required</h3></div>
+          <div data-workflow="approval-body"><p data-workflow="approval-message">{req().message}</p>
+            <Show when={req().approvers && req().approvers!.length > 0}><div data-workflow="approval-approvers"><For each={req().approvers!}>{(a) => <span data-workflow="approval-approver-badge">{a}</span>}</For></div></Show></div>
+          <div data-workflow="approval-actions"><button data-workflow="approval-reject" onClick={() => props.onReject(req().id)}>✕ Reject</button><button data-workflow="approval-approve" onClick={() => props.onApprove(req().id)}>✓ Approve</button></div>
+        </div>
+      </div>)}</Show>
+  )
+}

package/packages/solidjs/src/components/StepConfigPanel.tsx

@@ -0,0 +1,14 @@
+// @geenius-ai-workflow/solidjs — components/StepConfigPanel.tsx
+import { createSignal, Show } from 'solid-js'
+import type { WorkflowStepDef } from '@geenius-ai-workflow/shared'
+
+export function StepConfigPanel(props: { step: WorkflowStepDef; onUpdate: (id: string, u: Partial<WorkflowStepDef>) => void; onDelete: (id: string) => void; onClose: () => void }) {
+  const [name, setName] = createSignal(props.step.name)
+  return (
+    <div data-workflow="config-panel" role="complementary"><div data-workflow="config-header"><h3 data-workflow="config-title">Configure Step</h3><button data-workflow="config-close" onClick={props.onClose}>✕</button></div>
+    <div data-workflow="config-body"><label data-workflow="config-label">Step Name<input data-workflow="config-input" value={name()} onInput={(e) => setName(e.currentTarget.value)} onBlur={() => { if (name().trim() && name() !== props.step.name) props.onUpdate(props.step.id, { name: name().trim() }) }} /></label>
+    <div data-workflow="config-field"><span data-workflow="config-field-label">Type</span><span data-workflow="config-field-value">{props.step.type}</span></div>
+    <pre data-workflow="config-json-view">{JSON.stringify(props.step.config, null, 2)}</pre></div>
+    <div data-workflow="config-footer"><button data-workflow="config-delete" onClick={() => { props.onDelete(props.step.id); props.onClose() }}>🗑 Delete</button></div></div>
+  )
+}

package/packages/solidjs/src/components/StepConnector.tsx

@@ -0,0 +1,11 @@
+// @geenius-ai-workflow/solidjs — components/StepConnector.tsx
+const W = 200, H = 80
+export function StepConnector(props: { from: { x: number; y: number }; to: { x: number; y: number }; label?: string; isActive?: boolean }) {
+  const x1 = () => props.from.x + W, y1 = () => props.from.y + H / 2, x2 = () => props.to.x, y2 = () => props.to.y + H / 2, mx = () => (x1() + x2()) / 2
+  return (
+    <g data-workflow="connector" data-active={props.isActive || undefined}>
+      <path d={`M ${x1()} ${y1()} C ${mx()} ${y1()}, ${mx()} ${y2()}, ${x2()} ${y2()}`} fill="none" stroke={props.isActive ? 'oklch(0.7 0.2 145)' : 'oklch(0.5 0.02 260)'} stroke-width={props.isActive ? 3 : 2} />
+      {props.label && <text x={mx()} y={(y1() + y2()) / 2 - 8} text-anchor="middle" fill="oklch(0.7 0.02 260)" font-size="12">{props.label}</text>}
+    </g>
+  )
+}

package/packages/solidjs/src/components/StepNode.tsx

@@ -0,0 +1,12 @@
+// @geenius-ai-workflow/solidjs — components/StepNode.tsx
+import type { WorkflowStepDef, StepType } from '@geenius-ai-workflow/shared'
+const ICONS: Record<StepType, string> = { 'llm-call': '🤖', transform: '⚙️', condition: '🔀', 'human-approval': '👤', webhook: '🌐', delay: '⏱️', parallel: '⚡', loop: '🔄', 'sub-workflow': '📋', custom: '🔧' }
+
+export function StepNode(props: { step: WorkflowStepDef; isSelected?: boolean; status?: string; onClick?: () => void }) {
+  return (
+    <div data-workflow="step-node" data-step-type={props.step.type} data-selected={props.isSelected || undefined} data-status={props.status} role="button" tabIndex={0} onClick={props.onClick} style={props.step.position ? { position: 'absolute', left: `${props.step.position.x}px`, top: `${props.step.position.y}px` } : undefined}>
+      <div data-workflow="step-header"><span data-workflow="step-icon">{ICONS[props.step.type]}</span><span data-workflow="step-name">{props.step.name}</span></div>
+      <div data-workflow="step-type-badge">{props.step.type}</div>
+    </div>
+  )
+}

package/packages/solidjs/src/components/StepPalette.tsx

@@ -0,0 +1,22 @@
+// @geenius-ai-workflow/solidjs — components/StepPalette.tsx
+import { For } from 'solid-js'
+import type { StepType } from '@geenius-ai-workflow/shared'
+const ITEMS: Array<{ type: StepType; label: string; icon: string; desc: string }> = [
+  { type: 'llm-call', label: 'LLM Call', icon: '🤖', desc: 'Call an AI model' },
+  { type: 'transform', label: 'Transform', icon: '⚙️', desc: 'Transform data' },
+  { type: 'condition', label: 'Condition', icon: '🔀', desc: 'If/else branching' },
+  { type: 'human-approval', label: 'Approval', icon: '👤', desc: 'Human approval gate' },
+  { type: 'webhook', label: 'Webhook', icon: '🌐', desc: 'HTTP request' },
+  { type: 'delay', label: 'Delay', icon: '⏱️', desc: 'Wait for duration' },
+  { type: 'parallel', label: 'Parallel', icon: '⚡', desc: 'Run in parallel' },
+  { type: 'loop', label: 'Loop', icon: '🔄', desc: 'Iterate items' },
+  { type: 'sub-workflow', label: 'Sub-workflow', icon: '📋', desc: 'Run another workflow' },
+  { type: 'custom', label: 'Custom', icon: '🔧', desc: 'Custom handler' },
+]
+export function StepPalette(props: { onAddStep: (t: StepType) => void }) {
+  return (
+    <div data-workflow="step-palette" role="list"><h3 data-workflow="palette-title">Steps</h3>
+      <For each={ITEMS}>{(item) => <button data-workflow="palette-item" onClick={() => props.onAddStep(item.type)}><span data-workflow="palette-icon">{item.icon}</span><div data-workflow="palette-info"><span data-workflow="palette-label">{item.label}</span><span data-workflow="palette-desc">{item.desc}</span></div></button>}</For>
+    </div>
+  )
+}

package/packages/solidjs/src/components/WorkflowCanvas.tsx

@@ -0,0 +1,23 @@
+// @geenius-ai-workflow/solidjs — components/WorkflowCanvas.tsx
+import { For, Show } from 'solid-js'
+import type { WorkflowDefinition } from '@geenius-ai-workflow/shared'
+import { StepNode } from './StepNode'
+import { StepConnector } from './StepConnector'
+
+export function WorkflowCanvas(props: { definition: WorkflowDefinition; selectedStepId: string | null; onSelectStep: (id: string | null) => void }) {
+  return (
+    <div data-workflow="canvas" role="application" aria-label="Workflow canvas">
+      <svg data-workflow="connections-layer" style={{ position: 'absolute', inset: '0', 'pointer-events': 'none' }}>
+        <For each={props.definition.connections}>{(conn) => {
+          const from = () => props.definition.steps.find(s => s.id === conn.fromStepId)
+          const to = () => props.definition.steps.find(s => s.id === conn.toStepId)
+          return <Show when={from()?.position && to()?.position}><StepConnector from={from()!.position!} to={to()!.position!} label={conn.label} /></Show>
+        }}</For>
+      </svg>
+      <div data-workflow="nodes-layer">
+        <For each={props.definition.steps}>{(step) => <StepNode step={step} isSelected={props.selectedStepId === step.id} onClick={() => props.onSelectStep(step.id === props.selectedStepId ? null : step.id)} />}</For>
+      </div>
+      <Show when={props.definition.steps.length === 0}><div data-workflow="canvas-empty"><p data-workflow="empty-title">No steps yet</p></div></Show>
+    </div>
+  )
+}

package/packages/solidjs/src/components/WorkflowRunPanel.tsx

@@ -0,0 +1,18 @@
+// @geenius-ai-workflow/solidjs — components/WorkflowRunPanel.tsx
+import { Show, For } from 'solid-js'
+import type { WorkflowRun } from '@geenius-ai-workflow/shared'
+import { formatCost } from '@geenius-ai-workflow/shared'
+const SI: Record<string, string> = { pending: '⏳', running: '🔄', completed: '✅', failed: '❌', skipped: '⏭️', 'waiting-approval': '👤' }
+
+export function WorkflowRunPanel(props: { run: WorkflowRun | null; isRunning: boolean; onCancel?: () => void }) {
+  return (
+    <div data-workflow="run-panel" data-status={props.run?.status}><Show when={!props.run}><div data-workflow="run-empty"><p>No active run.</p></div></Show>
+    <Show when={props.run}>{(r) => { const done = () => r().stepResults.filter(s => s.status === 'completed').length; const total = () => r().stepResults.length; const pct = () => total() > 0 ? Math.round((done() / total()) * 100) : 0; const cost = () => r().stepResults.reduce((s, x) => s + (x.costUsd ?? 0), 0)
+      return (<><div data-workflow="run-header"><h3 data-workflow="run-title">{SI[r().status]} Run {r().status}</h3><Show when={props.isRunning && props.onCancel}><button data-workflow="run-cancel" onClick={props.onCancel}>⏹ Cancel</button></Show></div>
+        <div data-workflow="run-progress"><div data-workflow="run-progress-bar"><div data-workflow="run-progress-fill" style={{ width: `${pct()}%` }} /></div><span data-workflow="run-progress-text">{done()}/{total()} ({pct()}%)</span></div>
+        <Show when={cost() > 0}><span data-workflow="run-stat">💰 {formatCost(cost())}</span></Show>
+        <Show when={r().error}><div data-workflow="run-error">{r().error}</div></Show>
+        <ul data-workflow="run-steps"><For each={r().stepResults}>{(sr) => <li data-workflow="run-step-item" data-status={sr.status}><span>{SI[sr.status]}</span><span>{sr.stepName}</span><span>{sr.durationMs}ms</span></li>}</For></ul></>)
+    }}</Show></div>
+  )
+}

package/packages/solidjs/src/components/WorkflowToolbar.tsx

@@ -0,0 +1,13 @@
+// @geenius-ai-workflow/solidjs — components/WorkflowToolbar.tsx
+import { Show } from 'solid-js'
+
+export function WorkflowToolbar(props: { workflowName: string; isDirty: boolean; isRunning: boolean; canUndo: boolean; canRedo: boolean; onSave: () => void; onRun: () => void; onCancel?: () => void; onUndo: () => void; onRedo: () => void; onExport?: () => void }) {
+  return (
+    <div data-workflow="toolbar" role="toolbar">
+      <div data-workflow="toolbar-left"><h2 data-workflow="toolbar-title">{props.workflowName}</h2><Show when={props.isDirty}><span data-workflow="toolbar-dirty">●</span></Show></div>
+      <div data-workflow="toolbar-center"><button data-workflow="toolbar-btn" onClick={props.onUndo} disabled={!props.canUndo}>↶</button><button data-workflow="toolbar-btn" onClick={props.onRedo} disabled={!props.canRedo}>↷</button></div>
+      <div data-workflow="toolbar-right"><Show when={props.onExport}><button data-workflow="toolbar-btn-secondary" onClick={props.onExport}>📤 Export</button></Show><button data-workflow="toolbar-btn-secondary" onClick={props.onSave} disabled={!props.isDirty}>💾 Save</button>
+        <Show when={props.isRunning} fallback={<button data-workflow="toolbar-btn-primary" onClick={props.onRun}>▶ Run</button>}><button data-workflow="toolbar-btn-danger" onClick={props.onCancel}>⏹ Stop</button></Show></div>
+    </div>
+  )
+}

package/packages/solidjs/src/components/index.ts

@@ -0,0 +1,9 @@
+// @geenius-ai-workflow/solidjs — components/index.ts
+export { WorkflowCanvas } from './WorkflowCanvas'
+export { StepNode } from './StepNode'
+export { StepConnector } from './StepConnector'
+export { StepConfigPanel } from './StepConfigPanel'
+export { WorkflowRunPanel } from './WorkflowRunPanel'
+export { ApprovalModal } from './ApprovalModal'
+export { WorkflowToolbar } from './WorkflowToolbar'
+export { StepPalette } from './StepPalette'

package/packages/solidjs/src/index.ts

@@ -0,0 +1,7 @@
+// @geenius-ai-workflow/solidjs — src/index.ts
+export type { WorkflowDefinition, WorkflowStepDef, WorkflowRun, StepResult, WorkflowBuilderState } from '@geenius-ai-workflow/shared'
+export { WorkflowEngine, WORKFLOW_TEMPLATES } from '@geenius-ai-workflow/shared'
+
+export * from './primitives'
+export * from './components'
+export * from './pages'

package/packages/solidjs/src/pages/WorkflowBuilderPage.tsx

@@ -0,0 +1,37 @@
+// @geenius-ai-workflow/solidjs — pages/WorkflowBuilderPage.tsx
+import type { StepType, WorkflowStepDef } from '@geenius-ai-workflow/shared'
+import { WorkflowEngine } from '@geenius-ai-workflow/shared'
+import type { WorkflowEngineOptions } from '@geenius-ai-workflow/shared'
+import { Show } from 'solid-js'
+import { createWorkflowBuilder } from '../primitives/createWorkflowBuilder'
+import { createWorkflowRun } from '../primitives/createWorkflowRun'
+import { WorkflowCanvas } from '../components/WorkflowCanvas'
+import { WorkflowToolbar } from '../components/WorkflowToolbar'
+import { StepPalette } from '../components/StepPalette'
+import { StepConfigPanel } from '../components/StepConfigPanel'
+import { WorkflowRunPanel } from '../components/WorkflowRunPanel'
+
+export function WorkflowBuilderPage(props: { engineOptions: WorkflowEngineOptions; onSave?: (def: any) => void }) {
+  const builder = createWorkflowBuilder()
+  const runTracker = createWorkflowRun()
+  const handleAddStep = (type: StepType) => {
+    const step: WorkflowStepDef = { id: `step_${Date.now()}`, name: `New ${type}`, type, config: { type } as any, position: { x: 100 + builder.definition().steps.length * 250, y: 200 } }
+    builder.addStep(step)
+  }
+  const handleRun = async () => {
+    const engine = new WorkflowEngine({ ...props.engineOptions, onStepComplete: (r) => runTracker.updateStep(r) })
+    const result = await engine.execute(builder.definition())
+    runTracker.trackRun(result)
+  }
+  return (
+    <div data-workflow="builder-page">
+      <WorkflowToolbar workflowName={builder.definition().name} isDirty={builder.isDirty()} isRunning={runTracker.isRunning()} canUndo={builder.canUndo()} canRedo={builder.canRedo()} onSave={() => props.onSave?.(builder.definition())} onRun={handleRun} onUndo={builder.undo} onRedo={builder.redo} />
+      <div data-workflow="builder-layout">
+        <StepPalette onAddStep={handleAddStep} />
+        <WorkflowCanvas definition={builder.definition()} selectedStepId={builder.selectedStepId()} onSelectStep={builder.selectStep} />
+        <Show when={builder.selectedStepId()}>{(id) => { const step = () => builder.definition().steps.find(s => s.id === id()); return <Show when={step()}>{(s) => <StepConfigPanel step={s()} onUpdate={builder.updateStep} onDelete={builder.removeStep} onClose={() => builder.selectStep(null)} />}</Show> }}</Show>
+        <Show when={runTracker.run()}>{(r) => <WorkflowRunPanel run={r()} isRunning={runTracker.isRunning()} />}</Show>
+      </div>
+    </div>
+  )
+}

package/packages/solidjs/src/pages/WorkflowRunsPage.tsx

@@ -0,0 +1,20 @@
+// @geenius-ai-workflow/solidjs — pages/WorkflowRunsPage.tsx
+import { For, Show } from 'solid-js'
+import type { WorkflowRun } from '@geenius-ai-workflow/shared'
+const SI: Record<string, string> = { pending: '⏳', running: '🔄', completed: '✅', failed: '❌', cancelled: '⛔', paused: '⏸️' }
+
+export function WorkflowRunsPage(props: { runs: WorkflowRun[]; onSelectRun?: (id: string) => void }) {
+  return (
+    <div data-workflow="runs-page"><div data-workflow="runs-header"><h1 data-workflow="runs-title">Workflow Runs</h1><span data-workflow="runs-count">{props.runs.length} runs</span></div>
+    <Show when={props.runs.length > 0} fallback={<div data-workflow="runs-empty"><p>No runs yet.</p></div>}>
+      <div data-workflow="runs-list" role="list"><For each={props.runs}>{(run) => {
+        const done = () => run.stepResults.filter(s => s.status === 'completed').length
+        return (<div data-workflow="run-card" data-status={run.status} role="listitem" onClick={() => props.onSelectRun?.(run.id)}>
+          <div data-workflow="run-card-header"><span data-workflow="run-card-status">{SI[run.status]} {run.status}</span><span data-workflow="run-card-id">{run.id.slice(0, 8)}…</span></div>
+          <div data-workflow="run-card-meta"><span>{done()}/{run.stepResults.length} steps</span><span>{new Date(run.startedAt).toLocaleString()}</span></div>
+          <Show when={run.error}><p data-workflow="run-card-error">{run.error}</p></Show>
+        </div>)
+      }}</For></div>
+    </Show></div>
+  )
+}

package/packages/solidjs/src/pages/index.ts

@@ -0,0 +1,3 @@
+// @geenius-ai-workflow/solidjs — pages/index.ts
+export { WorkflowBuilderPage } from './WorkflowBuilderPage'
+export { WorkflowRunsPage } from './WorkflowRunsPage'

package/packages/solidjs/src/primitives/createApprovalGate.ts

@@ -0,0 +1,29 @@
+// @geenius-ai-workflow/solidjs — src/primitives/createApprovalGate.ts
+import { createSignal } from 'solid-js'
+
+export interface ApprovalRequest { id: string; stepId: string; message: string; requestedAt: number; approvers?: string[] }
+
+export function createApprovalGate() {
+  const [pendingApprovals, setPendingApprovals] = createSignal<ApprovalRequest[]>([])
+  const [history, setHistory] = createSignal<Array<ApprovalRequest & { decision: 'approved' | 'rejected'; decidedAt: number }>>([])
+
+  const requestApproval = (stepId: string, message: string, approvers?: string[]) => {
+    const request: ApprovalRequest = { id: `approval_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`, stepId, message, requestedAt: Date.now(), approvers }
+    setPendingApprovals(prev => [...prev, request])
+    return request.id
+  }
+
+  const approve = (id: string) => {
+    const req = pendingApprovals().find(a => a.id === id)
+    if (req) setHistory(h => [...h, { ...req, decision: 'approved', decidedAt: Date.now() }])
+    setPendingApprovals(prev => prev.filter(a => a.id !== id))
+  }
+
+  const reject = (id: string) => {
+    const req = pendingApprovals().find(a => a.id === id)
+    if (req) setHistory(h => [...h, { ...req, decision: 'rejected', decidedAt: Date.now() }])
+    setPendingApprovals(prev => prev.filter(a => a.id !== id))
+  }
+
+  return { pendingApprovals, history, hasPending: () => pendingApprovals().length > 0, requestApproval, approve, reject, clearHistory: () => setHistory([]) }
+}

package/packages/solidjs/src/primitives/createWorkflow.ts

@@ -0,0 +1,28 @@
+// @geenius-ai-workflow/solidjs — src/primitives/createWorkflow.ts
+import { createSignal } from 'solid-js'
+import type { WorkflowDefinition, WorkflowRun, StepResult } from '@geenius-ai-workflow/shared'
+import { WorkflowEngine } from '@geenius-ai-workflow/shared'
+import type { WorkflowEngineOptions } from '@geenius-ai-workflow/shared'
+
+export interface CreateWorkflowOptions extends WorkflowEngineOptions { }
+
+export function createWorkflow(options: CreateWorkflowOptions) {
+    const [run, setRun] = createSignal<WorkflowRun | null>(null)
+    const [isRunning, setIsRunning] = createSignal(false)
+    const [error, setError] = createSignal<Error | null>(null)
+    const [stepResults, setStepResults] = createSignal<StepResult[]>([])
+
+    const engine = new WorkflowEngine({
+        ...options,
+        onStepComplete: (result) => { setStepResults(prev => [...prev, result]); options.onStepComplete?.(result) },
+    })
+
+    const execute = async (definition: WorkflowDefinition, input?: Record<string, unknown>) => {
+        setIsRunning(true); setError(null); setStepResults([])
+        try { const res = await engine.execute(definition, input); setRun(res); return res }
+        catch (err) { const e = err instanceof Error ? err : new Error(String(err)); setError(e); throw e }
+        finally { setIsRunning(false) }
+    }
+
+    return { execute, cancel: () => engine.cancel(), run, isRunning, error, stepResults, reset: () => { setRun(null); setError(null); setStepResults([]) } }
+}

package/packages/solidjs/src/primitives/createWorkflowBuilder.ts

@@ -0,0 +1,56 @@
+// @geenius-ai-workflow/solidjs — src/primitives/createWorkflowBuilder.ts
+import { createSignal } from 'solid-js'
+import type { WorkflowDefinition, WorkflowStepDef, StepConnection, WorkflowBuilderState } from '@geenius-ai-workflow/shared'
+
+const emptyDef = (): WorkflowDefinition => ({
+    id: crypto.randomUUID?.() ?? String(Date.now()), name: 'New Workflow', version: 1, status: 'draft',
+    steps: [], connections: [], createdBy: '', createdAt: Date.now(), updatedAt: Date.now(),
+})
+
+export function createWorkflowBuilder(initial?: Partial<WorkflowDefinition>) {
+    const [state, setState] = createSignal<WorkflowBuilderState>({
+        definition: { ...emptyDef(), ...initial }, selectedStepId: null, isDirty: false, undoStack: [], redoStack: [],
+    })
+
+    const pushUndo = () => setState(prev => ({ ...prev, undoStack: [...prev.undoStack.slice(-20), prev.definition], redoStack: [] }))
+
+    const addStep = (step: WorkflowStepDef) => {
+        pushUndo(); setState(prev => ({ ...prev, isDirty: true, definition: { ...prev.definition, steps: [...prev.definition.steps, step], updatedAt: Date.now() } }))
+    }
+
+    const removeStep = (stepId: string) => {
+        pushUndo(); setState(prev => ({
+            ...prev, isDirty: true,
+            definition: { ...prev.definition, steps: prev.definition.steps.filter(s => s.id !== stepId), connections: prev.definition.connections.filter(c => c.fromStepId !== stepId && c.toStepId !== stepId), updatedAt: Date.now() },
+            selectedStepId: prev.selectedStepId === stepId ? null : prev.selectedStepId,
+        }))
+    }
+
+    const updateStep = (stepId: string, updates: Partial<WorkflowStepDef>) => {
+        pushUndo(); setState(prev => ({ ...prev, isDirty: true, definition: { ...prev.definition, steps: prev.definition.steps.map(s => s.id === stepId ? { ...s, ...updates } : s), updatedAt: Date.now() } }))
+    }
+
+    const addConnection = (conn: StepConnection) => {
+        pushUndo(); setState(prev => ({ ...prev, isDirty: true, definition: { ...prev.definition, connections: [...prev.definition.connections, conn], updatedAt: Date.now() } }))
+    }
+
+    const removeConnection = (fromStepId: string, toStepId: string) => {
+        pushUndo(); setState(prev => ({ ...prev, isDirty: true, definition: { ...prev.definition, connections: prev.definition.connections.filter(c => !(c.fromStepId === fromStepId && c.toStepId === toStepId)), updatedAt: Date.now() } }))
+    }
+
+    const selectStep = (stepId: string | null) => setState(prev => ({ ...prev, selectedStepId: stepId }))
+
+    const undo = () => setState(prev => {
+        if (prev.undoStack.length === 0) return prev
+        return { ...prev, definition: prev.undoStack[prev.undoStack.length - 1], undoStack: prev.undoStack.slice(0, -1), redoStack: [prev.definition, ...prev.redoStack] }
+    })
+
+    const redo = () => setState(prev => {
+        if (prev.redoStack.length === 0) return prev
+        return { ...prev, definition: prev.redoStack[0], undoStack: [...prev.undoStack, prev.definition], redoStack: prev.redoStack.slice(1) }
+    })
+
+    const setDefinition = (def: WorkflowDefinition) => setState({ definition: def, selectedStepId: null, isDirty: false, undoStack: [], redoStack: [] })
+
+    return { state, addStep, removeStep, updateStep, addConnection, removeConnection, selectStep, undo, redo, setDefinition }
+}