apply format change

Author: kination

Makefile

@@ -108,6 +108,14 @@ lint-config: golangci-lint ## Verify golangci-lint linter configuration
 build: manifests generate fmt vet ## Build manager binary.
 	go build -o bin/manager cmd/main.go
 
+.PHONY: build-cli
+build-cli: ## Build dag-cli binary.
+	go build -o bin/dag-cli cmd/dag-cli/main.go
+
+.PHONY: compile-dags
+compile-dags: build-cli ## Compile DAG definitions to YAML manifests.
+	./bin/dag-cli compile
+
 .PHONY: run
 run: manifests generate fmt vet ## Run a controller from your host.
 	go run ./cmd/main.go

README.md

@@ -1,93 +1,255 @@
-# nautikus
-// TODO: 
+# Nautikus
+
+A Kubernetes-native workflow engine built with the Operator pattern, similar to Apache Airflow. Define DAGs (Directed Acyclic Graphs) as code and let Kubernetes orchestrate your workflows.
+
+## Features
+
+- 📝 **Define DAGs in Code**: Write workflows in Go or Python
+- 🔄 **Automatic Compilation**: Convert code to Kubernetes manifests (YAML)
+- 🎯 **Dependency Management**: Define task dependencies with ease
+- 🚀 **Native Kubernetes**: Runs as a Kubernetes controller
+- 🔧 **Multiple Task Types**: Support for Bash, Python, and Go tasks
 
 ## Getting Started
 
 ### Prerequisites
-- go (version v1.24.6+).
-- docker (version 17.03+).
-- kubectl (version v1.11.3+).
+- Go (version v1.24.6+)
+- Docker (version 17.03+)
+- kubectl (version v1.11.3+)
+- kind (for local testing)
 
-### To Deploy on cluster
-1. Build & push your image to location specified by `IMG`:
+## Quick Start: Local Development
 
+### 1. Create a local cluster
 ```sh
-make docker-build docker-push IMG=<some-registry>/nautikus:tag
+kind create cluster --name nautikus
 ```
 
-2. Install the CRDs into the cluster:
+### 2. Build and load image
+```sh
+make docker-build IMG=nautikus:v1
+kind load docker-image nautikus:v1 --name nautikus
+```
 
+### 3. Install CRDs and deploy controller
 ```sh
 make install
+make deploy IMG=nautikus:v1
 ```
 
-3. Deploy the Manager to the cluster with image specified by `IMG`:
+### 4. Verify deployment
+```sh
+kubectl get pods -n nautikus-system
+```
 
+### 5. Compile and run a DAG
+
+**Option A: Use pre-defined YAML**
 ```sh
-make deploy IMG=<some-registry>/nautikus:tag
+kubectl apply -f config/samples/workflow_v1_dag_test.yaml
 ```
 
-> If you encounter RBAC errors, you may need to grant yourself cluster-admin privileges or be logged in as admin.
+**Option B: Define DAG in code and compile**
+```sh
+# Using go run
+go run cmd/dag-cli/main.go compile
+
+# Or build the CLI first
+make build-cli
+./bin/dag-cli compile
 
-4. Create instances of your solution.
-You can apply samples from config/sample:
+# Or use make target
+make compile-dags
+
+# Apply the generated YAML
+kubectl apply -f dist/go_dag.yaml
+```
 
+### CLI Options
 ```sh
-kubectl apply -k config/samples/
+# View all available commands
+./bin/dag-cli --help
+
+# View compile command options
+./bin/dag-cli compile --help
+
+# Compile with custom config and output directory
+./bin/dag-cli compile --config my-config.yaml --out output/
+
+# Short flags
+./bin/dag-cli compile -c my-config.yaml -o output/
+
+# Check version
+./bin/dag-cli version
 ```
 
-> Ensure that samples has default values to test it out.
+### 6. Monitor DAG execution
+```sh
+# Check DAG status
+kubectl get dags
+
+# View detailed status
+kubectl describe dag go-generated-dag
+
+# Check task pods
+kubectl get pods
 
-### To Uninstall
-1. Delete the instances (CRs) from cluster:
+# View controller logs
+kubectl logs -n nautikus-system -l control-plane=controller-manager -f
+```
 
+### 7. Cleanup
 ```sh
-kubectl delete -k config/samples/
+kubectl delete dags --all
+make undeploy
+make uninstall
+kind delete cluster --name nautikus
 ```
 
-2. Delete the APIs(CRDs) from cluster:
+## Writing DAGs in Code
+
+### Go Example (`test/dags/my_workflow.go`)
+
+```go
+package main
+
+import (
+    "encoding/json"
+    "fmt"
+    workflowv1 "github.com/kination/nautikus/api/v1"
+    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func main() {
+    dag := workflowv1.Dag{
+        TypeMeta: metav1.TypeMeta{
+            APIVersion: "workflow.nautikus.io/v1",
+            Kind:       "Dag",
+        },
+        ObjectMeta: metav1.ObjectMeta{
+            Name: "my-workflow",
+        },
+        Spec: workflowv1.DagSpec{
+            Tasks: []workflowv1.TaskSpec{
+                {
+                    Name:    "task-1",
+                    Type:    workflowv1.TaskTypeBash,
+                    Command: "echo 'Hello from Task 1'",
+                },
+                {
+                    Name:         "task-2",
+                    Type:         workflowv1.TaskTypePython,
+                    Dependencies: []string{"task-1"},
+                    Script:       "print('Hello from Task 2')",
+                },
+            },
+        },
+    }
+    
+    output, _ := json.MarshalIndent(dag, "", "  ")
+    fmt.Println(string(output))
+}
+```
 
+Then compile and apply:
 ```sh
-make uninstall
+# Using the CLI binary
+make build-cli
+./bin/dag-cli compile
+
+# Or using go run
+go run cmd/dag-cli/main.go compile
+
+# Or using make target
+make compile-dags
+
+# Apply the generated manifest
+kubectl apply -f dist/my_workflow.yaml
 ```
 
-3. UnDeploy the controller from cluster:
+## Production Deployment
 
+### 1. Build & push your image
 ```sh
-make undeploy
+make docker-build docker-push IMG=<your-registry>/nautikus:tag
 ```
 
-## How to test in local
+### 2. Install CRDs
+```sh
+make install
+```
 
-1. **Create a local cluster**
+### 3. Deploy controller
 ```sh
-kind create cluster --name nautikus
+make deploy IMG=<your-registry>/nautikus:tag
 ```
 
-2. **Build and load image**
+### 4. Create DAG instances
 ```sh
-make docker-build IMG=nautikus:v1
-kind load docker-image nautikus:v1 --name nautikus
+kubectl apply -k config/samples/
 ```
 
-3. **Deploy controller**
+## Uninstall
+
+### 1. Delete DAG instances
 ```sh
-make deploy IMG=nautikus:v1
+kubectl delete -k config/samples/
 ```
 
-4. **Verify deployment**
+### 2. Remove CRDs
 ```sh
-kubectl get pods -n nautikus-system
+make uninstall
 ```
 
-5. **Run a test DAG**
+### 3. Undeploy controller
 ```sh
-kubectl apply -f config/samples/workflow_v1_dag_test.yaml
-kubectl get dags
-kubectl logs -n nautikus-system -l control-plane=controller-manager
+make undeploy
 ```
 
-6. **Cleanup**
+## Development
+
+### Run tests
 ```sh
-kind delete cluster --name nautikus
+make test
 ```
+
+### Run E2E tests
+```sh
+make test-e2e
+```
+
+### Run controller locally (without Docker)
+```sh
+make run
+```
+
+### Generate code and manifests
+```sh
+make manifests  # Generate CRDs
+make generate   # Generate DeepCopy methods
+```
+
+## Project Structure
+
+```
+nautikus/
+├── api/v1/              # CRD definitions
+├── cmd/
+│   ├── main.go          # Controller entrypoint
+│   └── dag-cli/         # DAG compiler CLI
+├── internal/
+│   ├── controller/      # Reconciliation logic
+│   └── compiler/        # Code-to-YAML compiler
+├── config/              # Kubernetes manifests
+│   ├── crd/            # CRD definitions
+│   ├── rbac/           # RBAC rules
+│   └── samples/        # Example DAGs
+├── test/dags/          # Example DAG definitions
+└── dist/               # Compiled YAML output (gitignored)
+```
+
+## License
+
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0.

api/v1/dag_types.go

@@ -20,9 +20,10 @@ type TaskSpec struct {
 	Dependencies []string `json:"dependencies,omitempty"` // Parent tasks that must be completed before this task can run
 
 	// Execution details for each task type
-	Command string `json:"command,omitempty"` // For Bash tasks
-	Script  string `json:"script,omitempty"`  // For Python/Go code
-	Image   string `json:"image,omitempty"`   // Custom container image if needed
+	Command string            `json:"command,omitempty"` // For Bash tasks
+	Script  string            `json:"script,omitempty"`  // For Python/Go code
+	Image   string            `json:"image,omitempty"`   // Custom container image if needed
+	Env     map[string]string `json:"env,omitempty"`     // Environment variables for the task
 }
 
 // DagSpec defines the complete specification of a DAG as defined by the user.