hexdag 0.5.0.dev1__tar.gz → 0.5.0.dev3__tar.gz

{hexdag-0.5.0.dev1 → hexdag-0.5.0.dev3}/.gitignore

@@ -10,8 +10,8 @@ dist/
 downloads/
 eggs/
 .eggs/
-lib/
-lib64/
+/lib/
+/lib64/
 parts/
 sdist/
 var/

{hexdag-0.5.0.dev1 → hexdag-0.5.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexdag
-Version: 0.5.0.dev1
+Version: 0.5.0.dev3
 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 → hexdag-0.5.0.dev3}/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-0.5.0.dev1 → hexdag-0.5.0.dev3}/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-0.5.0.dev1 → hexdag-0.5.0.dev3}/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-0.5.0.dev1 → hexdag-0.5.0.dev3}/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-0.5.0.dev1 → hexdag-0.5.0.dev3}/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-0.5.0.dev1 → hexdag-0.5.0.dev3}/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-0.5.0.dev3/hexdag/studio/ui/src/lib/api.ts

@@ -0,0 +1,227 @@
+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[] = []
+
+    for (const plugin of plugins) {
+      const pluginNodes = Array.isArray(plugin.nodes) ? plugin.nodes : []
+      for (const node of pluginNodes) {
+        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[] = []
+
+    for (const plugin of plugins) {
+      const pluginAdapters = Array.isArray(plugin.adapters) ? plugin.adapters : []
+      for (const adapter of pluginAdapters) {
+        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 {
+    const response = await apiRequest<PluginInfo[] | { plugins: PluginInfo[] }>('/plugins')
+    // Handle both array response and object with plugins property
+    if (Array.isArray(response)) {
+      return response
+    }
+    if (response && typeof response === 'object' && 'plugins' in response && Array.isArray(response.plugins)) {
+      return response.plugins
+    }
+    console.warn('Unexpected plugins response format:', response)
+    return []
+  } 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-0.5.0.dev3/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 || []
+}