hexdag 0.5.0.dev1__py3-none-any.whl → 0.5.0.dev2__py3-none-any.whl

hexdag/studio/ui/src/components/Canvas.tsx

@@ -92,7 +92,7 @@ export default function Canvas({ onNodeSelect, selectedNodeId }: CanvasProps) {
         setTimeout(() => {
           const currentNodes = useStudioStore.getState().nodes
           const deletedIds = deletions.map((d) => d.id)
-          const newNodes = currentNodes.filter((n) => !deletedIds.includes(n.id))
+          const newNodes = currentNodes.filter((n: HexdagNodeType) => !deletedIds.includes(n.id))
           setStoreNodes(newNodes)
           syncCanvasToYaml()
 

hexdag/studio/ui/src/components/NodeInspector.tsx

@@ -5,7 +5,7 @@ import { getNodeTemplate, nodeTemplates } from '../lib/nodeTemplates'
 import PythonEditor from './PythonEditor'
 import PortsEditor from './PortsEditor'
 import NodePortsSection from './NodePortsSection'
-import type { HexdagNode } from '../types'
+import type { HexdagNode, HexdagEdge, NodeTemplate } from '../types'
 
 interface NodeInspectorProps {
   nodeId: string | null
@@ -16,7 +16,7 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
   const { nodes, setNodes, edges, setEdges, syncCanvasToYaml } = useStudioStore()
   const [expandedSections, setExpandedSections] = useState<Set<string>>(new Set(['general', 'spec']))
 
-  const node = nodes.find((n) => n.id === nodeId)
+  const node = nodes.find((n: HexdagNode) => n.id === nodeId)
   const template = node ? getNodeTemplate(node.data.kind) : null
 
   // Show PortsEditor when no node is selected
@@ -36,7 +36,7 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
 
   const updateNode = (updates: Partial<HexdagNode['data']>) => {
     setNodes(
-      nodes.map((n) =>
+      nodes.map((n: HexdagNode) =>
         n.id === nodeId
           ? { ...n, data: { ...n.data, ...updates } }
           : n
@@ -60,14 +60,14 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
     if (!newName || newName === nodeId) return
 
     // Check for duplicates
-    if (nodes.some((n) => n.id === newName)) {
+    if (nodes.some((n: HexdagNode) => n.id === newName)) {
       alert('A node with this name already exists')
       return
     }
 
     // Update node id
     setNodes(
-      nodes.map((n) =>
+      nodes.map((n: HexdagNode) =>
         n.id === nodeId
           ? { ...n, id: newName, data: { ...n.data, label: newName } }
           : n
@@ -76,7 +76,7 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
 
     // Update edges
     setEdges(
-      edges.map((e) => ({
+      edges.map((e: HexdagEdge) => ({
         ...e,
         id: e.id.replace(nodeId, newName),
         source: e.source === nodeId ? newName : e.source,
@@ -100,8 +100,8 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
   const deleteNode = () => {
     if (!confirm(`Delete node "${nodeId}"?`)) return
 
-    setNodes(nodes.filter((n) => n.id !== nodeId))
-    setEdges(edges.filter((e) => e.source !== nodeId && e.target !== nodeId))
+    setNodes(nodes.filter((n: HexdagNode) => n.id !== nodeId))
+    setEdges(edges.filter((e: HexdagEdge) => e.source !== nodeId && e.target !== nodeId))
     syncCanvasToYaml()
     onClose()
   }
@@ -109,7 +109,7 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
   const duplicateNode = () => {
     let newName = `${nodeId}_copy`
     let counter = 1
-    while (nodes.some((n) => n.id === newName)) {
+    while (nodes.some((n: HexdagNode) => n.id === newName)) {
       newName = `${nodeId}_copy_${counter}`
       counter++
     }
@@ -132,7 +132,7 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
   }
 
   // Get dependencies (incoming edges)
-  const dependencies = edges.filter((e) => e.target === nodeId).map((e) => e.source)
+  const dependencies = edges.filter((e: HexdagEdge) => e.target === nodeId).map((e: HexdagEdge) => e.source)
 
   return (
     <div className="h-full flex flex-col bg-hex-surface">
@@ -198,7 +198,7 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
               onChange={(e) => changeNodeKind(e.target.value)}
               className="w-full bg-hex-bg border border-hex-border rounded px-2 py-1.5 text-xs text-hex-text focus:border-hex-accent focus:outline-none"
             >
-              {nodeTemplates.map((t) => (
+              {nodeTemplates.map((t: NodeTemplate) => (
                 <option key={t.kind} value={t.kind}>
                   {t.label}
                 </option>
@@ -211,7 +211,7 @@ export default function NodeInspector({ nodeId, onClose }: NodeInspectorProps) {
               {dependencies.length === 0 ? (
                 <div className="text-[10px] text-hex-text-muted italic">No dependencies</div>
               ) : (
-                dependencies.map((dep) => (
+                dependencies.map((dep: string) => (
                   <div
                     key={dep}
                     className="flex items-center gap-2 text-xs bg-hex-bg rounded px-2 py-1"

hexdag/studio/ui/src/components/NodePalette.tsx

@@ -23,6 +23,7 @@ import {
 } from 'lucide-react'
 import { nodeTemplates } from '../lib/nodeTemplates'
 import { getAllPluginNodes, type PluginNode } from '../lib/api'
+import type { NodeTemplate } from '../types'
 
 const iconMap: Record<string, typeof Code> = {
   Code,
@@ -60,7 +61,7 @@ export default function NodePalette() {
 
       // Group nodes by plugin
       const groupedNodes = nodes.reduce(
-        (acc, node) => {
+        (acc: Record<string, PluginNode[]>, node: PluginNode) => {
           const plugin = node.plugin || 'unknown'
           if (!acc[plugin]) {
             acc[plugin] = []
@@ -72,7 +73,7 @@ export default function NodePalette() {
       )
 
       setPluginNodeSections(
-        Object.entries(groupedNodes).map(([plugin, nodes]) => ({
+        Object.entries(groupedNodes).map(([plugin, nodes]: [string, PluginNode[]]) => ({
           plugin,
           nodes,
           expanded: true,
@@ -134,7 +135,7 @@ export default function NodePalette() {
           </button>
           {builtinExpanded && (
             <div className="px-2 pb-2 space-y-1">
-              {nodeTemplates.map((template) => {
+              {nodeTemplates.map((template: NodeTemplate) => {
                 const Icon = iconMap[template.icon] || Box
                 return (
                   <div

hexdag/studio/ui/src/components/PluginManager.tsx

@@ -247,7 +247,7 @@ function PluginCard({
                 Adapters ({plugin.adapters.length})
               </h4>
               <div className="grid grid-cols-2 gap-2">
-                {plugin.adapters.map((adapter, idx) => {
+                {plugin.adapters.map((adapter: PluginAdapter, idx: number) => {
                   const Icon = getAdapterIcon(adapter)
                   const color = getPortTypeColor(adapter.port_type)
                   return (
@@ -300,7 +300,7 @@ function PluginCard({
                 Nodes ({plugin.nodes.length})
               </h4>
               <div className="grid grid-cols-2 gap-2">
-                {plugin.nodes.map((node, idx) => (
+                {plugin.nodes.map((node: PluginNode, idx: number) => (
                   <NodeCard key={idx} node={node} />
                 ))}
               </div>

hexdag/studio/ui/src/components/ValidationPanel.tsx

@@ -1,5 +1,6 @@
 import { CheckCircle, XCircle, AlertTriangle, Info } from 'lucide-react'
 import { useStudioStore } from '../lib/store'
+import type { ValidationError } from '../types'
 
 export default function ValidationPanel() {
   const { validation } = useStudioStore()
@@ -15,8 +16,8 @@ export default function ValidationPanel() {
     )
   }
 
-  const errorCount = validation.errors.filter((e) => e.severity === 'error').length
-  const warningCount = validation.errors.filter((e) => e.severity === 'warning').length
+  const errorCount = validation.errors.filter((e: ValidationError) => e.severity === 'error').length
+  const warningCount = validation.errors.filter((e: ValidationError) => e.severity === 'warning').length
 
   return (
     <div className="h-full flex flex-col">
@@ -68,7 +69,7 @@ export default function ValidationPanel() {
           </div>
         )}
 
-        {validation.errors.map((error, index) => (
+        {validation.errors.map((error: ValidationError, index: number) => (
           <div
             key={index}
             className={`

hexdag/studio/ui/src/components/YamlEditor.tsx

@@ -3,6 +3,7 @@ import Editor, { type OnMount, type OnChange } from '@monaco-editor/react'
 import type * as Monaco from 'monaco-editor'
 import { useStudioStore } from '../lib/store'
 import { validateYaml } from '../lib/api'
+import type { ValidationError } from '../types'
 
 export default function YamlEditor() {
   const editorRef = useRef<Monaco.editor.IStandaloneCodeEditor | null>(null)
@@ -124,7 +125,7 @@ export default function YamlEditor() {
       if (monacoRef.current && editorRef.current) {
         const model = editorRef.current.getModel()
         if (model) {
-          const markers: Monaco.editor.IMarkerData[] = result.errors.map((err) => ({
+          const markers: Monaco.editor.IMarkerData[] = result.errors.map((err: ValidationError) => ({
             severity: err.severity === 'error'
               ? monacoRef.current!.MarkerSeverity.Error
               : err.severity === 'warning'

hexdag/studio/ui/src/lib/api.ts

@@ -0,0 +1,216 @@
+import type { FileInfo, FileContent, ValidationResult } from '../types'
+
+const API_BASE = '/api'
+
+// Plugin types
+export interface PluginNode {
+  kind: string
+  name: string
+  description?: string
+  plugin: string
+  color: string
+  defaultSpec?: Record<string, unknown>
+}
+
+export interface PluginAdapter {
+  name: string
+  port_type: string
+  plugin: string
+  description?: string
+  config_schema?: Record<string, unknown>
+  secrets: string[]
+}
+
+export interface PluginInfo {
+  name: string
+  version: string
+  description?: string
+  author?: string
+  adapters: PluginAdapter[]
+  nodes: PluginNode[]
+  enabled: boolean
+}
+
+// Execution types
+export interface ExecutionResult {
+  success: boolean
+  outputs?: Record<string, unknown>
+  error?: string
+  execution_time?: number
+  duration_ms: number
+  node_results?: Record<string, unknown>
+}
+
+// Helper function for API requests
+async function apiRequest<T>(
+  endpoint: string,
+  options: RequestInit = {}
+): Promise<T> {
+  const url = `${API_BASE}${endpoint}`
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options.headers,
+    },
+  })
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`API error: ${response.status} - ${error}`)
+  }
+
+  return response.json()
+}
+
+// File operations
+export async function listFiles(path: string = '.'): Promise<FileInfo[]> {
+  return apiRequest<FileInfo[]>(`/files?path=${encodeURIComponent(path)}`)
+}
+
+export async function readFile(path: string): Promise<FileContent> {
+  return apiRequest<FileContent>(`/files/${encodeURIComponent(path)}`)
+}
+
+export async function saveFile(path: string, content: string): Promise<void> {
+  await apiRequest(`/files/${encodeURIComponent(path)}`, {
+    method: 'PUT',
+    body: JSON.stringify({ content }),
+  })
+}
+
+export async function deleteFile(path: string): Promise<void> {
+  await apiRequest(`/files/${encodeURIComponent(path)}`, {
+    method: 'DELETE',
+  })
+}
+
+// Validation
+export async function validateYaml(
+  content: string,
+  filePath?: string
+): Promise<ValidationResult> {
+  return apiRequest<ValidationResult>('/validate', {
+    method: 'POST',
+    body: JSON.stringify({ content, file_path: filePath }),
+  })
+}
+
+// Execution
+export async function executePipeline(
+  yaml: string,
+  inputs: Record<string, unknown> = {},
+  dryRun: boolean = false
+): Promise<ExecutionResult> {
+  return apiRequest<ExecutionResult>('/execute', {
+    method: 'POST',
+    body: JSON.stringify({
+      yaml,
+      inputs,
+      dry_run: dryRun,
+    }),
+  })
+}
+
+// Project operations
+export async function downloadProject(
+  yamlContent?: string,
+  filename?: string,
+  includeAssets?: boolean
+): Promise<void> {
+  const response = await fetch(`${API_BASE}/project/download`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      yaml: yamlContent,
+      filename,
+      include_assets: includeAssets,
+    }),
+  })
+  if (!response.ok) {
+    throw new Error(`Failed to download project: ${response.status}`)
+  }
+
+  const blob = await response.blob()
+  const url = window.URL.createObjectURL(blob)
+  const a = document.createElement('a')
+  a.href = url
+  a.download = filename || 'hexdag-project.zip'
+  document.body.appendChild(a)
+  a.click()
+  document.body.removeChild(a)
+  window.URL.revokeObjectURL(url)
+}
+
+// Plugin discovery
+export async function getAllPluginNodes(): Promise<PluginNode[]> {
+  try {
+    const plugins = await listPlugins()
+    const nodes: PluginNode[] = []
+
+    plugins.forEach((plugin) => {
+      plugin.nodes.forEach((node) => {
+        nodes.push({
+          ...node,
+          plugin: plugin.name,
+        })
+      })
+    })
+
+    return nodes
+  } catch (error) {
+    console.error('Failed to get plugin nodes:', error)
+    return []
+  }
+}
+
+export async function getAllPluginAdapters(): Promise<PluginAdapter[]> {
+  try {
+    const plugins = await listPlugins()
+    const adapters: PluginAdapter[] = []
+
+    plugins.forEach((plugin) => {
+      plugin.adapters.forEach((adapter) => {
+        adapters.push({
+          ...adapter,
+          plugin: plugin.name,
+        })
+      })
+    })
+
+    return adapters
+  } catch (error) {
+    console.error('Failed to get plugin adapters:', error)
+    return []
+  }
+}
+
+export async function listPlugins(): Promise<PluginInfo[]> {
+  try {
+    return await apiRequest<PluginInfo[]>('/plugins')
+  } catch (error) {
+    console.error('Failed to list plugins:', error)
+    return []
+  }
+}
+
+// Registry endpoints
+export async function getRegisteredNodes(): Promise<
+  Array<{ kind: string; name: string; namespace: string }>
+> {
+  try {
+    return await apiRequest('/registry/nodes')
+  } catch {
+    return []
+  }
+}
+
+export async function getRegisteredAdapters(): Promise<
+  Array<{ name: string; port_type: string; namespace: string }>
+> {
+  try {
+    return await apiRequest('/registry/adapters')
+  } catch {
+    return []
+  }
+}

hexdag/studio/ui/src/lib/nodeTemplates.ts

@@ -0,0 +1,207 @@
+import type { NodeTemplate } from '../types'
+
+// Built-in hexDAG node templates
+export const nodeTemplates: NodeTemplate[] = [
+  {
+    kind: 'function_node',
+    label: 'Function',
+    description: 'Execute Python functions',
+    icon: 'Code',
+    color: '#3b82f6', // blue-500
+    defaultSpec: {
+      fn: '',
+    },
+  },
+  {
+    kind: 'llm_node',
+    label: 'LLM',
+    description: 'Language model interactions',
+    icon: 'Brain',
+    color: '#8b5cf6', // violet-500
+    defaultSpec: {
+      prompt_template: '',
+    },
+    requiredPorts: ['llm'],
+  },
+  {
+    kind: 'agent_node',
+    label: 'Agent',
+    description: 'ReAct agent with tools',
+    icon: 'Bot',
+    color: '#ec4899', // pink-500
+    defaultSpec: {
+      initial_prompt_template: '',
+      max_steps: 5,
+    },
+    requiredPorts: ['llm', 'tool_router'],
+  },
+  {
+    kind: 'conditional_node',
+    label: 'Conditional',
+    description: 'Conditional branching',
+    icon: 'GitBranch',
+    color: '#f59e0b', // amber-500
+    defaultSpec: {
+      condition: '',
+      if_true: null,
+      if_false: null,
+    },
+  },
+  {
+    kind: 'loop_node',
+    label: 'Loop',
+    description: 'Iterative processing',
+    icon: 'Repeat',
+    color: '#10b981', // emerald-500
+    defaultSpec: {
+      iterations: 1,
+      body: null,
+    },
+  },
+  {
+    kind: 'input_node',
+    label: 'Input',
+    description: 'Pipeline input',
+    icon: 'FileText',
+    color: '#06b6d4', // cyan-500
+    defaultSpec: {
+      schema: {},
+    },
+  },
+  {
+    kind: 'output_node',
+    label: 'Output',
+    description: 'Pipeline output',
+    icon: 'FileText',
+    color: '#14b8a6', // teal-500
+    defaultSpec: {
+      schema: {},
+    },
+  },
+  {
+    kind: 'transform_node',
+    label: 'Transform',
+    description: 'Data transformation',
+    icon: 'Scissors',
+    color: '#f97316', // orange-500
+    defaultSpec: {
+      transform_fn: '',
+    },
+  },
+  {
+    kind: 'parallel_node',
+    label: 'Parallel',
+    description: 'Parallel execution',
+    icon: 'Cpu',
+    color: '#6366f1', // indigo-500
+    defaultSpec: {
+      branches: [],
+    },
+  },
+]
+
+// Map of kind to template for quick lookup
+const templateMap = new Map<string, NodeTemplate>(
+  nodeTemplates.map((t) => [t.kind, t])
+)
+
+// Default colors for unknown node kinds
+const defaultColors: Record<string, string> = {
+  function: '#3b82f6',
+  llm: '#8b5cf6',
+  agent: '#ec4899',
+  conditional: '#f59e0b',
+  loop: '#10b981',
+  input: '#06b6d4',
+  output: '#14b8a6',
+  transform: '#f97316',
+  parallel: '#6366f1',
+  default: '#6b7280',
+}
+
+/**
+ * Get a node template by kind
+ */
+export function getNodeTemplate(kind: string): NodeTemplate | undefined {
+  // Direct lookup
+  if (templateMap.has(kind)) {
+    return templateMap.get(kind)
+  }
+
+  // Try with _node suffix
+  if (templateMap.has(`${kind}_node`)) {
+    return templateMap.get(`${kind}_node`)
+  }
+
+  // Handle namespaced kinds (e.g., 'etl:file_reader_node')
+  if (kind.includes(':')) {
+    const baseName = kind.split(':').pop()
+    if (baseName && templateMap.has(baseName)) {
+      return templateMap.get(baseName)
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Get the color for a node kind
+ */
+export function getNodeColor(kind: string): string {
+  // Try to get from template
+  const template = getNodeTemplate(kind)
+  if (template) {
+    return template.color
+  }
+
+  // Try to match based on kind name
+  const kindLower = kind.toLowerCase()
+  for (const [key, color] of Object.entries(defaultColors)) {
+    if (kindLower.includes(key)) {
+      return color
+    }
+  }
+
+  return defaultColors.default
+}
+
+/**
+ * Get the icon name for a node kind
+ */
+export function getNodeIcon(kind: string): string {
+  const template = getNodeTemplate(kind)
+  if (template) {
+    return template.icon
+  }
+
+  // Default icons based on kind name
+  const kindLower = kind.toLowerCase()
+  if (kindLower.includes('function')) return 'Code'
+  if (kindLower.includes('llm')) return 'Brain'
+  if (kindLower.includes('agent')) return 'Bot'
+  if (kindLower.includes('conditional') || kindLower.includes('branch'))
+    return 'GitBranch'
+  if (kindLower.includes('loop') || kindLower.includes('repeat')) return 'Repeat'
+  if (kindLower.includes('input') || kindLower.includes('output'))
+    return 'FileText'
+  if (kindLower.includes('transform')) return 'Scissors'
+  if (kindLower.includes('parallel')) return 'Cpu'
+
+  return 'Box'
+}
+
+/**
+ * Get the default spec for a node kind
+ */
+export function getDefaultSpec(kind: string): Record<string, unknown> {
+  const template = getNodeTemplate(kind)
+  return template?.defaultSpec || {}
+}
+
+/**
+ * Get required ports for a node kind
+ */
+export function getRequiredPorts(kind: string): string[] {
+  const template = getNodeTemplate(kind)
+  return template?.requiredPorts || []
+}

hexdag/studio/ui/src/lib/store.ts

@@ -0,0 +1,247 @@
+import { create } from 'zustand'
+import yaml from 'yaml'
+import type {
+  FileInfo,
+  HexdagNode,
+  HexdagEdge,
+  ValidationResult,
+  StudioState,
+  Pipeline,
+  NodeSpec,
+} from '../types'
+
+// Helper to calculate node positions in a DAG layout
+function calculateNodePositions(
+  nodes: NodeSpec[]
+): Map<string, { x: number; y: number }> {
+  const positions = new Map<string, { x: number; y: number }>()
+
+  // Build dependency graph
+  const dependencyMap = new Map<string, string[]>()
+  const dependentMap = new Map<string, string[]>()
+
+  nodes.forEach((node) => {
+    dependencyMap.set(node.metadata.name, node.dependencies || [])
+    dependentMap.set(node.metadata.name, [])
+  })
+
+  // Build reverse dependency map
+  nodes.forEach((node) => {
+    ;(node.dependencies || []).forEach((dep) => {
+      const dependents = dependentMap.get(dep) || []
+      dependents.push(node.metadata.name)
+      dependentMap.set(dep, dependents)
+    })
+  })
+
+  // Calculate levels (topological sort with levels)
+  const levels = new Map<string, number>()
+  const visited = new Set<string>()
+
+  function calculateLevel(nodeName: string): number {
+    if (levels.has(nodeName)) {
+      return levels.get(nodeName)!
+    }
+    if (visited.has(nodeName)) {
+      return 0 // Cycle detected, return 0
+    }
+
+    visited.add(nodeName)
+    const deps = dependencyMap.get(nodeName) || []
+    let maxDepLevel = -1
+
+    deps.forEach((dep) => {
+      const depLevel = calculateLevel(dep)
+      maxDepLevel = Math.max(maxDepLevel, depLevel)
+    })
+
+    const level = maxDepLevel + 1
+    levels.set(nodeName, level)
+    return level
+  }
+
+  nodes.forEach((node) => calculateLevel(node.metadata.name))
+
+  // Group nodes by level
+  const levelGroups = new Map<number, string[]>()
+  levels.forEach((level, nodeName) => {
+    const group = levelGroups.get(level) || []
+    group.push(nodeName)
+    levelGroups.set(level, group)
+  })
+
+  // Calculate positions
+  const nodeWidth = 200
+  const nodeHeight = 80
+  const horizontalGap = 100
+  const verticalGap = 50
+
+  levelGroups.forEach((nodesAtLevel, level) => {
+    const totalWidth =
+      nodesAtLevel.length * nodeWidth + (nodesAtLevel.length - 1) * horizontalGap
+    const startX = -totalWidth / 2
+
+    nodesAtLevel.forEach((nodeName, index) => {
+      positions.set(nodeName, {
+        x: startX + index * (nodeWidth + horizontalGap) + 100,
+        y: level * (nodeHeight + verticalGap) + 50,
+      })
+    })
+  })
+
+  return positions
+}
+
+export const useStudioStore = create<StudioState>((set, get) => ({
+  // Files
+  files: [],
+  currentFile: null,
+  yamlContent: '',
+
+  // Canvas
+  nodes: [],
+  edges: [],
+
+  // Validation
+  validation: null,
+
+  // UI state
+  isLoading: false,
+  isSaving: false,
+  isDirty: false,
+
+  // Actions
+  setFiles: (files: FileInfo[]) => set({ files }),
+  setCurrentFile: (path: string | null) => set({ currentFile: path }),
+  setYamlContent: (content: string) => set({ yamlContent: content, isDirty: true }),
+  setNodes: (nodes: HexdagNode[]) => set({ nodes }),
+  setEdges: (edges: HexdagEdge[]) => set({ edges }),
+  setValidation: (result: ValidationResult | null) => set({ validation: result }),
+  setIsLoading: (loading: boolean) => set({ isLoading: loading }),
+  setIsSaving: (saving: boolean) => set({ isSaving: saving }),
+  setIsDirty: (dirty: boolean) => set({ isDirty: dirty }),
+
+  // Complex actions
+  syncYamlToCanvas: () => {
+    const { yamlContent } = get()
+
+    if (!yamlContent.trim()) {
+      set({ nodes: [], edges: [] })
+      return
+    }
+
+    try {
+      const parsed = yaml.parse(yamlContent) as Pipeline | null
+
+      if (!parsed || !parsed.spec || !parsed.spec.nodes) {
+        set({ nodes: [], edges: [] })
+        return
+      }
+
+      const pipelineNodes = parsed.spec.nodes
+      const positions = calculateNodePositions(pipelineNodes)
+      const existingNodes = get().nodes
+      const existingPositions = new Map(
+        existingNodes.map((n) => [n.id, n.position])
+      )
+
+      // Convert pipeline nodes to canvas nodes
+      const canvasNodes: HexdagNode[] = pipelineNodes.map((node) => {
+        const existingPos = existingPositions.get(node.metadata.name)
+        const calculatedPos = positions.get(node.metadata.name) || { x: 0, y: 0 }
+
+        return {
+          id: node.metadata.name,
+          type: 'hexdagNode',
+          position: existingPos || calculatedPos,
+          data: {
+            kind: node.kind,
+            label: node.metadata.name,
+            spec: node.spec || {},
+            isValid: true,
+            errors: [],
+          },
+        }
+      })
+
+      // Build edges from dependencies
+      const canvasEdges: HexdagEdge[] = []
+      pipelineNodes.forEach((node) => {
+        ;(node.dependencies || []).forEach((dep) => {
+          canvasEdges.push({
+            id: `${dep}-${node.metadata.name}`,
+            source: dep,
+            target: node.metadata.name,
+            type: 'smoothstep',
+            animated: false,
+          })
+        })
+      })
+
+      set({ nodes: canvasNodes, edges: canvasEdges })
+    } catch (error) {
+      console.error('Failed to parse YAML:', error)
+      // Keep existing nodes/edges on parse error
+    }
+  },
+
+  syncCanvasToYaml: () => {
+    const { nodes, edges, yamlContent } = get()
+
+    if (nodes.length === 0) {
+      // Don't clear YAML if there are no nodes - could be a parse error state
+      return
+    }
+
+    try {
+      // Parse existing YAML to preserve metadata and ports
+      let existingPipeline: Pipeline | null = null
+      try {
+        existingPipeline = yaml.parse(yamlContent) as Pipeline | null
+      } catch {
+        // If YAML is invalid, start fresh
+      }
+
+      // Build dependency map from edges
+      const dependencyMap = new Map<string, string[]>()
+      edges.forEach((edge) => {
+        const deps = dependencyMap.get(edge.target) || []
+        deps.push(edge.source)
+        dependencyMap.set(edge.target, deps)
+      })
+
+      // Convert canvas nodes to pipeline nodes
+      const pipelineNodes: NodeSpec[] = nodes.map((node) => ({
+        kind: node.data.kind,
+        metadata: {
+          name: node.id,
+        },
+        spec: node.data.spec || {},
+        dependencies: dependencyMap.get(node.id) || [],
+      }))
+
+      // Build the pipeline object
+      const pipeline: Pipeline = {
+        apiVersion: existingPipeline?.apiVersion || 'hexdag/v1',
+        kind: existingPipeline?.kind || 'Pipeline',
+        metadata: existingPipeline?.metadata || {
+          name: 'untitled-pipeline',
+        },
+        spec: {
+          ports: existingPipeline?.spec?.ports,
+          nodes: pipelineNodes,
+        },
+      }
+
+      // Serialize to YAML
+      const newYamlContent = yaml.stringify(pipeline, {
+        indent: 2,
+        lineWidth: 120,
+      })
+
+      set({ yamlContent: newYamlContent, isDirty: true })
+    } catch (error) {
+      console.error('Failed to serialize to YAML:', error)
+    }
+  },
+}))

{hexdag-0.5.0.dev1.dist-info → hexdag-0.5.0.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexdag
-Version: 0.5.0.dev1
+Version: 0.5.0.dev2
 Summary: Lightweight DAG orchestration framework with enterprise pipeline capabilities
 Project-URL: Homepage, https://hexdag.ai
 Project-URL: Repository, https://github.com/omniviser/hexdag

{hexdag-0.5.0.dev1.dist-info → hexdag-0.5.0.dev2.dist-info}/RECORD

@@ -180,20 +180,23 @@ hexdag/studio/ui/src/App.tsx,sha256=xBnZsJTFh3WvZWIGjmjb5ghoXruY61H_wjNEnuXQCb8,
 hexdag/studio/ui/src/index.css,sha256=akRMqCLDkxXGpoDXOoQ5dk87goJwqIdAuadxf2l_INY,1393
 hexdag/studio/ui/src/main.tsx,sha256=X0nc5ubMS11njPUp74kq8Kt9-mr7MAsRrVWSJAGbiwU,232
 hexdag/studio/ui/src/vite-env.d.ts,sha256=ZZlpNvuwQpFfe3SiAPzd5-QQ8ypmmxq5WXz6pLD63bU,38
-hexdag/studio/ui/src/components/Canvas.tsx,sha256=xQjAn9MyCARoSY5PUfLnTdpdEykfG-XbWxbbXz5CefQ,11837
+hexdag/studio/ui/src/components/Canvas.tsx,sha256=ijgR3aNKv5BUARcOsEZRgq74M_dH0hzCfh_XPoBA_7g,11853
 hexdag/studio/ui/src/components/ContextMenu.tsx,sha256=3IcJdG3oeaeeicxa3FXiYQAc52W7A5dGWwwKce3yrwI,4671
 hexdag/studio/ui/src/components/FileBrowser.tsx,sha256=ejsBKjktPL7vKQpkf7rnbNkaKy_M4DdLfwdzN9IKyJY,3836
 hexdag/studio/ui/src/components/Header.tsx,sha256=zQSXsjUzV13KbenjEh_A35_TuuqN5Fnu6JoAAYJ6T8c,5702
 hexdag/studio/ui/src/components/HexdagNode.tsx,sha256=HmeNEoxUzQzAzTb3AHMjsQrYC_4QYFiywO96rSboRJ8,6419
-hexdag/studio/ui/src/components/NodeInspector.tsx,sha256=bEFl5B01xwIf-8p8-4II63qTQVCf9bib7cakSBQ1wmM,16335
-hexdag/studio/ui/src/components/NodePalette.tsx,sha256=LsjV4IzO9P0SXHNi36HgXzPQmynJzfw9C8JLWtyQtoI,9636
+hexdag/studio/ui/src/components/NodeInspector.tsx,sha256=15gW-Xz6BkYJYB4zYooKl_l0qSgbBYiklCCs0rgTqPU,16503
+hexdag/studio/ui/src/components/NodePalette.tsx,sha256=yLhfN4CvfNkwqQXG2heStAyiiGm0v8ejVnA9jMLHqLc,9761
 hexdag/studio/ui/src/components/NodePortsSection.tsx,sha256=nkUaVEJ4oIAfpwYTQYuHNr6jDb-OaxD_FD5D3d0amWw,12474
-hexdag/studio/ui/src/components/PluginManager.tsx,sha256=QaqePTLsM5N7lKLWPVYz3B7fZz3B7Gbw4ePeeYXEm8U,12446
+hexdag/studio/ui/src/components/PluginManager.tsx,sha256=CzMzUKnwHW7W65nnwbaU899U6yWFzSkZ2ZQ9A-iKDnU,12489
 hexdag/studio/ui/src/components/PortsEditor.tsx,sha256=h3b8GCKVeiT7DY99oEKm9HowtCG5xau3akzDZl_Owbc,15039
 hexdag/studio/ui/src/components/PythonEditor.tsx,sha256=vJ7sgZ6s75651EI7Y-GTv2s5sODlNi2ay9XDtmL2Xww,6770
-hexdag/studio/ui/src/components/ValidationPanel.tsx,sha256=b6EXyq0PcG0eQRFw5-Axvuy48HbMWudQ4i9oBJWoWwY,4050
-hexdag/studio/ui/src/components/YamlEditor.tsx,sha256=U6a2qWC6hSLYFgjlL_bh-GH0COYwUKk7zLmM7SIU1A4,6716
+hexdag/studio/ui/src/components/ValidationPanel.tsx,sha256=lzRIgwso2j-_NLFOu8j9GCQWkn6KB-d-6eWG9x4nmHs,4157
+hexdag/studio/ui/src/components/YamlEditor.tsx,sha256=naD2dSq9rw6hxbA6Fkj9-8fmU0vRF1Rk1_FfpPqksfU,6781
 hexdag/studio/ui/src/components/index.ts,sha256=fjXeu-PS5GD5m-My52619toCqWqQRuZHDPfJ_rQ4ZIk,428
+hexdag/studio/ui/src/lib/api.ts,sha256=s6pO1mzmNR7EpLHdHrrjXHwP2pCMyHKBUCwXvhF8y0c,4960
+hexdag/studio/ui/src/lib/nodeTemplates.ts,sha256=s8zOfsQGhpCG7foPdrsFtQ_CGwN6jcZTXe_fCbTno5M,4743
+hexdag/studio/ui/src/lib/store.ts,sha256=aynI_K5oioi7Zq0WhC_oIrhSNximBSnD54xPe6JTgi4,6902
 hexdag/studio/ui/src/types/index.ts,sha256=ZWKo_eHfPnMGVXqMa0SZuB5VSOdDDLQy7RkhkVA1qPo,2592
 hexdag/visualization/__init__.py,sha256=B7pF_eVt6ompQUometQK0EA3ARZItzguNZbYmEiVxu4,1889
 hexdag/visualization/dag_visualizer.py,sha256=MsLL7CuOC-iC5-xm5doKk6iH0n1CDMklqZn35nZaigU,38790
@@ -254,8 +257,8 @@ hexdag_plugins/storage/vector/__init__.py,sha256=uMI7dYdgMpm5b-Kay3Z9OehTC8kfqvJ
 hexdag_plugins/storage/vector/chromadb.py,sha256=CZBtp4EAw6WGwJ4M8WYc0KYVdbTJLiP74pF3JxSZIgI,7103
 hexdag_plugins/storage/vector/in_memory.py,sha256=j_7FAXj8nQPxPAIksaeOyU5yFJijOXxYEJCRibwttB8,8390
 hexdag_plugins/storage/vector/pgvector.py,sha256=830TWR4JrwbpzYultCIfb7Tll_D0te3xJM3PXCHyH94,18262
-hexdag-0.5.0.dev1.dist-info/METADATA,sha256=QqkFJqeQkZEFR6XxedhGq7VmALGAHlJDGohyElMV8gQ,13940
-hexdag-0.5.0.dev1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-hexdag-0.5.0.dev1.dist-info/entry_points.txt,sha256=HVVYo840xI_sDh7Ld4V6JikuEKykjCv-hdB8lND48FU,144
-hexdag-0.5.0.dev1.dist-info/licenses/LICENSE,sha256=ha-Tqaxjm6OqBpizGHUnQk1XxuU9_M9xMFTSz_kJzxk,10760
-hexdag-0.5.0.dev1.dist-info/RECORD,,
+hexdag-0.5.0.dev2.dist-info/METADATA,sha256=3xMVd05Np-dSbZNKwCrpqni03ZoRS0f6r0ons3_p3aM,13940
+hexdag-0.5.0.dev2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hexdag-0.5.0.dev2.dist-info/entry_points.txt,sha256=HVVYo840xI_sDh7Ld4V6JikuEKykjCv-hdB8lND48FU,144
+hexdag-0.5.0.dev2.dist-info/licenses/LICENSE,sha256=ha-Tqaxjm6OqBpizGHUnQk1XxuU9_M9xMFTSz_kJzxk,10760
+hexdag-0.5.0.dev2.dist-info/RECORD,,