hexdag 0.5.0.dev1__py3-none-any.whl

hexdag/studio/__init__.py

@@ -0,0 +1,10 @@
+"""hexdag studio - Local-first visual editor for hexdag pipelines.
+
+Usage:
+    hexdag studio ./pipelines/
+
+Opens a browser-based editor that reads/writes YAML files directly.
+No cloud, no accounts - just local files that work with git.
+"""
+
+__version__ = "0.1.0"

hexdag/studio/build_ui.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Build script for hexdag studio UI.
+
+This script builds the React UI and bundles it into the dist folder
+which is served by the FastAPI server.
+
+Usage:
+    python -m hexdag.studio.build_ui
+
+Requirements:
+    - Node.js 18+
+    - npm or pnpm
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def build_ui() -> int:
+    """Build the React UI."""
+    ui_dir = Path(__file__).parent / "ui"
+
+    if not ui_dir.exists():
+        print(f"Error: UI directory not found: {ui_dir}")
+        return 1
+
+    print("Building hexdag studio UI...")
+    print(f"  Directory: {ui_dir}")
+
+    # Check for package.json
+    package_json = ui_dir / "package.json"
+    if not package_json.exists():
+        print(f"Error: package.json not found: {package_json}")
+        return 1
+
+    # Try npm first, then pnpm
+    npm_cmd = "npm"
+    try:
+        subprocess.run([npm_cmd, "--version"], capture_output=True, check=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        npm_cmd = "pnpm"
+        try:
+            subprocess.run([npm_cmd, "--version"], capture_output=True, check=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            print("Error: Neither npm nor pnpm found. Please install Node.js.")
+            return 1
+
+    print(f"  Using: {npm_cmd}")
+
+    # Install dependencies
+    print("\n[1/2] Installing dependencies...")
+    result = subprocess.run(
+        [npm_cmd, "install"],
+        cwd=ui_dir,
+        capture_output=False,
+    )
+    if result.returncode != 0:
+        print("Error: Failed to install dependencies")
+        return result.returncode
+
+    # Build
+    print("\n[2/2] Building production bundle...")
+    result = subprocess.run(
+        [npm_cmd, "run", "build"],
+        cwd=ui_dir,
+        capture_output=False,
+    )
+    if result.returncode != 0:
+        print("Error: Failed to build")
+        return result.returncode
+
+    dist_dir = ui_dir / "dist"
+    if dist_dir.exists():
+        print("\nBuild complete!")
+        print(f"  Output: {dist_dir}")
+
+        # List built files
+        print("\nBuilt files:")
+        for f in dist_dir.rglob("*"):
+            if f.is_file():
+                size = f.stat().st_size
+                rel_path = f.relative_to(dist_dir)
+                print(f"  {rel_path} ({size:,} bytes)")
+    else:
+        print("Warning: dist directory not created")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(build_ui())

hexdag/studio/server/__init__.py

@@ -0,0 +1 @@
+"""FastAPI server for hexdag studio."""

hexdag/studio/server/main.py

@@ -0,0 +1,100 @@
+"""FastAPI server for hexdag studio.
+
+Local-first visual editor for hexdag pipelines.
+"""
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from hexdag.studio.server.routes import (
+    execute_router,
+    export_router,
+    files_router,
+    plugins_router,
+    validate_router,
+)
+from hexdag.studio.server.routes.files import set_workspace_root
+
+
+def create_app(workspace_path: Path) -> FastAPI:
+    """Create FastAPI application for hexdag studio.
+
+    Args:
+        workspace_path: Root directory for pipeline files
+    """
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+        # Startup
+        set_workspace_root(workspace_path)
+        print(f"Workspace: {workspace_path}")
+        yield
+        # Shutdown
+        pass
+
+    app = FastAPI(
+        title="hexdag studio",
+        description="Local-first visual editor for hexdag pipelines",
+        version="0.1.0",
+        lifespan=lifespan,
+    )
+
+    # CORS for local development
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["http://localhost:3141", "http://127.0.0.1:3141", "http://localhost:5173"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # API routes
+    app.include_router(files_router, prefix="/api")
+    app.include_router(validate_router, prefix="/api")
+    app.include_router(execute_router, prefix="/api")
+    app.include_router(export_router, prefix="/api")
+    app.include_router(plugins_router, prefix="/api")
+
+    # Health check
+    @app.get("/api/health")
+    async def health() -> dict[str, str]:
+        return {"status": "ok", "workspace": str(workspace_path)}
+
+    # Serve static UI files
+    ui_path = Path(__file__).parent.parent / "ui" / "dist"
+    if ui_path.exists():
+        app.mount("/assets", StaticFiles(directory=ui_path / "assets"), name="assets")
+
+        @app.get("/")
+        async def serve_index() -> FileResponse:
+            return FileResponse(ui_path / "index.html")
+
+        @app.get("/{path:path}")
+        async def serve_spa(path: str) -> FileResponse:
+            # SPA fallback - serve index.html for all non-API routes
+            file_path = ui_path / path
+            if file_path.exists() and file_path.is_file():
+                return FileResponse(file_path)
+            return FileResponse(ui_path / "index.html")
+
+    return app
+
+
+def run_server(workspace_path: Path, host: str = "127.0.0.1", port: int = 3141) -> None:
+    """Run the studio server.
+
+    Args:
+        workspace_path: Root directory for pipeline files
+        host: Host to bind to
+        port: Port to bind to
+    """
+    import uvicorn
+
+    app = create_app(workspace_path)
+    uvicorn.run(app, host=host, port=port, log_level="info")

hexdag/studio/server/routes/__init__.py

@@ -0,0 +1,9 @@
+"""API routes for hexdag studio."""
+
+from hexdag.studio.server.routes.execute import router as execute_router
+from hexdag.studio.server.routes.export import router as export_router
+from hexdag.studio.server.routes.files import router as files_router
+from hexdag.studio.server.routes.plugins import router as plugins_router
+from hexdag.studio.server.routes.validate import router as validate_router
+
+__all__ = ["files_router", "validate_router", "execute_router", "export_router", "plugins_router"]

hexdag/studio/server/routes/execute.py

@@ -0,0 +1,208 @@
+"""Execution API for hexdag studio.
+
+Provides test execution of pipelines with mock adapters.
+"""
+
+import asyncio
+import sys
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from hexdag.studio.server.routes.files import get_workspace_root
+
+router = APIRouter(prefix="/execute", tags=["execute"])
+
+
+class ExecuteRequest(BaseModel):
+    """Request to execute a pipeline."""
+
+    content: str
+    inputs: dict[str, Any] = {}
+    use_mocks: bool = True
+    timeout: float = 30.0
+
+
+class NodeResult(BaseModel):
+    """Result from a single node execution."""
+
+    name: str
+    status: str  # completed, failed, skipped
+    output: Any | None = None
+    error: str | None = None
+    duration_ms: float | None = None
+
+
+class ExecuteResponse(BaseModel):
+    """Pipeline execution result."""
+
+    success: bool
+    nodes: list[NodeResult]
+    final_output: Any | None = None
+    error: str | None = None
+    duration_ms: float
+
+
+@router.post("", response_model=ExecuteResponse)
+async def execute_pipeline(request: ExecuteRequest) -> ExecuteResponse:
+    """Execute a pipeline with optional mock adapters.
+
+    This is for testing/preview purposes. Production execution
+    should use the CLI or programmatic API.
+    """
+    import time
+
+    start = time.perf_counter()
+    node_results: list[NodeResult] = []
+
+    # Add workspace root to sys.path so local modules (like tools/) can be imported
+    try:
+        workspace_root = get_workspace_root()
+        # Check if workspace has a parent with tools/adapters (project root pattern)
+        # e.g., workspace is "examples/raven/pipelines", project root is "examples/raven"
+        project_root = (
+            workspace_root.parent if workspace_root.name == "pipelines" else workspace_root
+        )
+        project_root_str = str(project_root)
+        if project_root_str not in sys.path:
+            sys.path.insert(0, project_root_str)
+    except Exception:
+        pass  # Workspace not set, continue without modification
+
+    try:
+        from hexdag.core.orchestration.orchestrator import Orchestrator
+        from hexdag.core.pipeline_builder import YamlPipelineBuilder
+
+        # Build pipeline
+        builder = YamlPipelineBuilder()
+        graph, config = builder.build_from_yaml_string(request.content)
+
+        # Create orchestrator with mocks if requested
+        if request.use_mocks:
+            # Use mock adapters for safe testing
+            from hexdag.builtin.adapters.memory import InMemoryMemory
+            from hexdag.builtin.adapters.mock import MockLLM
+
+            orchestrator = Orchestrator(
+                ports={
+                    "llm": MockLLM(),
+                    "memory": InMemoryMemory(),
+                }
+            )
+        else:
+            orchestrator = Orchestrator()
+
+        # Track node results via events
+        node_timings: dict[str, float] = {}
+
+        def on_node_started(event: Any) -> None:
+            node_timings[event.node_id] = time.perf_counter()
+
+        def on_node_completed(event: Any) -> None:
+            start_time = node_timings.get(event.node_id, start)
+            duration = (time.perf_counter() - start_time) * 1000
+            node_results.append(
+                NodeResult(
+                    name=event.node_id,
+                    status="completed",
+                    output=event.output if hasattr(event, "output") else None,
+                    duration_ms=duration,
+                )
+            )
+
+        def on_node_failed(event: Any) -> None:
+            start_time = node_timings.get(event.node_id, start)
+            duration = (time.perf_counter() - start_time) * 1000
+            node_results.append(
+                NodeResult(
+                    name=event.node_id,
+                    status="failed",
+                    error=str(event.error) if hasattr(event, "error") else "Unknown error",
+                    duration_ms=duration,
+                )
+            )
+
+        # Subscribe to events
+        orchestrator.on("node_started", on_node_started)
+        orchestrator.on("node_completed", on_node_completed)
+        orchestrator.on("node_failed", on_node_failed)
+
+        # Execute with timeout
+        try:
+            result = await asyncio.wait_for(
+                orchestrator.run(graph, request.inputs),
+                timeout=request.timeout,
+            )
+            success = True
+            final_output = result
+            error = None
+        except TimeoutError:
+            success = False
+            final_output = None
+            error = f"Execution timed out after {request.timeout}s"
+
+    except Exception as e:
+        success = False
+        final_output = None
+        error = str(e)
+
+    duration = (time.perf_counter() - start) * 1000
+
+    return ExecuteResponse(
+        success=success,
+        nodes=node_results,
+        final_output=final_output,
+        error=error,
+        duration_ms=duration,
+    )
+
+
+@router.post("/dry-run")
+async def dry_run(request: ExecuteRequest) -> dict[str, Any]:
+    """Analyze pipeline without executing.
+
+    Returns execution plan, dependency order, and estimated complexity.
+    """
+    # Add workspace root to sys.path for local module imports
+    try:
+        workspace_root = get_workspace_root()
+        project_root = (
+            workspace_root.parent if workspace_root.name == "pipelines" else workspace_root
+        )
+        project_root_str = str(project_root)
+        if project_root_str not in sys.path:
+            sys.path.insert(0, project_root_str)
+    except Exception:
+        pass
+
+    try:
+        from hexdag.core.pipeline_builder import YamlPipelineBuilder
+
+        builder = YamlPipelineBuilder()
+        graph, config = builder.build_from_yaml_string(request.content)
+
+        # Get execution order
+        execution_order = list(graph.topological_sort())
+
+        # Analyze dependencies
+        dependency_map = {}
+        for node_id in execution_order:
+            node = graph.get_node(node_id)
+            dependency_map[node_id] = {
+                "dependencies": list(node.dependencies) if node else [],
+                "kind": node.node_type if node and hasattr(node, "node_type") else "unknown",
+            }
+
+        return {
+            "valid": True,
+            "execution_order": execution_order,
+            "node_count": len(execution_order),
+            "dependency_map": dependency_map,
+        }
+
+    except Exception as e:
+        return {
+            "valid": False,
+            "error": str(e),
+        }