@geenius/ai-workflow 0.1.0 → 0.4.0

package/packages/shared/src/utils/dag.ts

@@ -1,133 +0,0 @@
-// @geenius-ai-workflow/shared — src/utils/dag.ts
-/**
- * DAG (Directed Acyclic Graph) utilities — topological sort, cycle detection, path finding.
- */
-
-export interface DAGNode { id: string }
-export interface DAGEdge { from: string; to: string }
-
-/**
- * Topological sort using Kahn's algorithm.
- * Returns sorted node IDs or throws if a cycle is detected.
- */
-export function topoSort(nodeIds: string[], edges: DAGEdge[]): string[] {
-  const inDegree = new Map<string, number>()
-  const adjacency = new Map<string, string[]>()
-
-  for (const id of nodeIds) {
-    inDegree.set(id, 0)
-    adjacency.set(id, [])
-  }
-
-  for (const edge of edges) {
-    adjacency.get(edge.from)?.push(edge.to)
-    inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1)
-  }
-
-  const queue: string[] = []
-  for (const [id, deg] of inDegree) {
-    if (deg === 0) queue.push(id)
-  }
-
-  const sorted: string[] = []
-  while (queue.length > 0) {
-    const id = queue.shift()!
-    sorted.push(id)
-    for (const neighbor of adjacency.get(id) ?? []) {
-      const newDeg = (inDegree.get(neighbor) ?? 1) - 1
-      inDegree.set(neighbor, newDeg)
-      if (newDeg === 0) queue.push(neighbor)
-    }
-  }
-
-  if (sorted.length !== nodeIds.length) {
-    throw new Error('Cycle detected in workflow DAG — topological sort is not possible')
-  }
-
-  return sorted
-}
-
-/**
- * Detect cycles using DFS. Returns the cycle path if one exists, or null.
- */
-export function detectCycle(nodeIds: string[], edges: DAGEdge[]): string[] | null {
-  const adjacency = new Map<string, string[]>()
-  for (const id of nodeIds) adjacency.set(id, [])
-  for (const edge of edges) adjacency.get(edge.from)?.push(edge.to)
-
-  const WHITE = 0, GRAY = 1, BLACK = 2
-  const color = new Map<string, number>()
-  const parent = new Map<string, string | null>()
-  for (const id of nodeIds) { color.set(id, WHITE); parent.set(id, null) }
-
-  for (const startId of nodeIds) {
-    if (color.get(startId) !== WHITE) continue
-    const stack = [startId]
-    while (stack.length > 0) {
-      const node = stack[stack.length - 1]
-      if (color.get(node) === WHITE) {
-        color.set(node, GRAY)
-        for (const neighbor of adjacency.get(node) ?? []) {
-          if (color.get(neighbor) === GRAY) {
-            // Build cycle path
-            const cycle = [neighbor, node]
-            let cur = node
-            while (cur !== neighbor && parent.get(cur)) {
-              cur = parent.get(cur)!
-              cycle.push(cur)
-            }
-            return cycle.reverse()
-          }
-          if (color.get(neighbor) === WHITE) {
-            parent.set(neighbor, node)
-            stack.push(neighbor)
-          }
-        }
-      } else {
-        color.set(node, BLACK)
-        stack.pop()
-      }
-    }
-  }
-
-  return null
-}
-
-/**
- * Find all paths from source to target in the DAG.
- */
-export function findPaths(nodeIds: string[], edges: DAGEdge[], source: string, target: string): string[][] {
-  const adjacency = new Map<string, string[]>()
-  for (const id of nodeIds) adjacency.set(id, [])
-  for (const edge of edges) adjacency.get(edge.from)?.push(edge.to)
-
-  const paths: string[][] = []
-  const dfs = (current: string, path: string[]) => {
-    if (current === target) { paths.push([...path]); return }
-    for (const neighbor of adjacency.get(current) ?? []) {
-      if (!path.includes(neighbor)) {
-        path.push(neighbor)
-        dfs(neighbor, path)
-        path.pop()
-      }
-    }
-  }
-  dfs(source, [source])
-  return paths
-}
-
-/**
- * Find entry nodes (no incoming edges) in the DAG.
- */
-export function findEntryNodes(nodeIds: string[], edges: DAGEdge[]): string[] {
-  const hasIncoming = new Set(edges.map(e => e.to))
-  return nodeIds.filter(id => !hasIncoming.has(id))
-}
-
-/**
- * Find exit nodes (no outgoing edges) in the DAG.
- */
-export function findExitNodes(nodeIds: string[], edges: DAGEdge[]): string[] {
-  const hasOutgoing = new Set(edges.map(e => e.from))
-  return nodeIds.filter(id => !hasOutgoing.has(id))
-}

package/packages/shared/src/utils/index.ts

@@ -1,5 +0,0 @@
-// @geenius-ai-workflow/shared — src/utils/index.ts
-export { interpolate, extractVariables, findMissingVariables } from './interpolation'
-export { topoSort, detectCycle, findPaths, findEntryNodes, findExitNodes } from './dag'
-export type { DAGNode, DAGEdge } from './dag'
-export { estimateTokens, estimateStepTokens, estimateStepCost, estimateWorkflowCost, calculateRunCost, formatCost, MODEL_RATES } from './cost'

package/packages/shared/src/utils/interpolation.ts

@@ -1,53 +0,0 @@
-// @geenius-ai-workflow/shared — src/utils/interpolation.ts
-/**
- * Template variable interpolation — {{varName}} syntax with nested access.
- */
-
-/** Resolve a dot-path like "user.name" from a nested object */
-function resolvePath(obj: Record<string, unknown>, path: string): unknown {
-  return path.split('.').reduce<unknown>((acc, key) => {
-    if (acc !== null && acc !== undefined && typeof acc === 'object') {
-      return (acc as Record<string, unknown>)[key]
-    }
-    return undefined
-  }, obj)
-}
-
-/**
- * Interpolate {{variable}} or {{nested.path}} references in a string.
- * Supports optional default values: {{varName|default}}.
- */
-export function interpolate(template: string, vars: Record<string, unknown>): string {
-  return template.replace(/\{\{([^}]+)\}\}/g, (match, expr: string) => {
-    const [path, defaultValue] = expr.trim().split('|').map((s: string) => s.trim())
-    const val = resolvePath(vars, path)
-    if (val !== undefined && val !== null) {
-      return typeof val === 'object' ? JSON.stringify(val) : String(val)
-    }
-    return defaultValue ?? match
-  })
-}
-
-/**
- * Extract all variable references from a template string.
- * Returns unique variable names (without defaults).
- */
-export function extractVariables(template: string): string[] {
-  const vars = new Set<string>()
-  const re = /\{\{([^}]+)\}\}/g
-  let m: RegExpExecArray | null
-  while ((m = re.exec(template)) !== null) {
-    const path = m[1].trim().split('|')[0].trim()
-    vars.add(path.split('.')[0]) // add root variable name
-  }
-  return [...vars]
-}
-
-/**
- * Check if all required variables in a template are present in the vars object.
- * Returns missing variable names.
- */
-export function findMissingVariables(template: string, vars: Record<string, unknown>): string[] {
-  const required = extractVariables(template)
-  return required.filter(v => vars[v] === undefined || vars[v] === null)
-}

package/packages/shared/src/validators.ts

@@ -1,215 +0,0 @@
-// @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

@@ -1 +0,0 @@
-{"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

@@ -1,5 +0,0 @@
-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

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

package/packages/solidjs/README.md

@@ -1 +0,0 @@
-# ✦ @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

@@ -1,45 +0,0 @@
-{
-  "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

@@ -1,18 +0,0 @@
-// @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

@@ -1,14 +0,0 @@
-// @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

@@ -1,11 +0,0 @@
-// @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

@@ -1,12 +0,0 @@
-// @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

@@ -1,22 +0,0 @@
-// @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

@@ -1,23 +0,0 @@
-// @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

@@ -1,18 +0,0 @@
-// @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

@@ -1,13 +0,0 @@
-// @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

@@ -1,9 +0,0 @@
-// @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

@@ -1,7 +0,0 @@
-// @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'