### Install Frontend Dependencies and Start Dev Server

Source: https://github.com/dagucloud/dagu/blob/main/CONTRIBUTING.md

Navigate to the UI directory, install dependencies using pnpm, and start the development server for hot-reloading.

```bash
cd ui
pnpm install
pnpm dev
```

--------------------------------

### Install Dependencies and Start Webpack Dev Server

Source: https://github.com/dagucloud/dagu/blob/main/ui/README.md

Navigate to the UI directory, install dependencies using pnpm, and start the Webpack dev server. The UI will be accessible at http://localhost:8081.

```bash
cd ui/
pnpm install
pnpm dev
```

--------------------------------

### Install minikube

Source: https://github.com/dagucloud/dagu/blob/main/deploy/k8s/README.md

Installs minikube using Homebrew and starts a local Kubernetes cluster.

```bash
brew install minikube
minikube start
```

--------------------------------

### Install Dagu from Source Checkout (Local Testing)

Source: https://github.com/dagucloud/dagu/blob/main/charts/dagu/README.md

Install the Dagu Helm chart from a local source checkout for testing. This command is equivalent to the previous example but uses a local chart path.

```bash
helm install dagu ./charts/dagu \
  --set persistence.accessMode=ReadWriteOnce \
  --set persistence.skipValidation=true \
  --set workerPools.general.replicas=1
```

--------------------------------

### Start Backend Server

Source: https://github.com/dagucloud/dagu/blob/main/CONTRIBUTING.md

Starts the backend server on port 8080. Ensure the DAGU_PORT environment variable is set.

```bash
DAGU_PORT=8080 make
```

--------------------------------

### Dagu Command Line Usage Examples

Source: https://github.com/dagucloud/dagu/blob/main/npm/dagu/README.md

Demonstrates common Dagu CLI commands for managing workflows, including starting the UI/scheduler, running a workflow, and checking status.

```bash
# Start the web UI and scheduler
dagu start-all

# Run a workflow
dagu start my-workflow.yaml

# Check workflow status
dagu status my-workflow.yaml
```

--------------------------------

### Install k3d

Source: https://github.com/dagucloud/dagu/blob/main/deploy/k8s/README.md

Installs k3d using Homebrew and creates a cluster named 'dagu-test' with two worker agents.

```bash
brew install k3d
k3d cluster create dagu-test --agents 2
```

--------------------------------

### Install kind

Source: https://github.com/dagucloud/dagu/blob/main/deploy/k8s/README.md

Installs kind (Kubernetes in Docker) using Homebrew and creates a cluster named 'dagu-test'.

```bash
brew install kind
kind create cluster --name dagu-test
```

--------------------------------

### Minimal Dagu Workflow Example

Source: https://github.com/dagucloud/dagu/blob/main/README_SCHEMA.md

A basic Dagu workflow demonstrating 'run' and 'action' step types, parameter usage, and dependency management. Use this as a starting point for defining your own workflows.

```yaml
name: release-check
type: graph

params:
  ENVIRONMENT: staging

steps:
  - id: test
    run: go test ./...

  - id: health
    action: http.request
    with:
      method: GET
      url: https://example.com/health
    depends: [test]

  - id: deploy
    run: ./deploy.sh ${ENVIRONMENT}
    depends: [health]
    retry_policy:
      limit: 3
      interval_sec: 10

```

--------------------------------

### Start a DAG for Immediate Local Execution

Source: https://github.com/dagucloud/dagu/blob/main/internal/agent/system_prompt.txt

Use 'dagu start' only when the user explicitly requests immediate local execution instead of queueing.

```bash
dagu start
```

--------------------------------

### Example Project Structure

Source: https://github.com/dagucloud/dagu/blob/main/specs/001-project.md

Illustrates a typical Dagu project layout with configuration, pipelines, and workflows.

```text
project/
  .dagu.json
  pipelines/
    deploy.yaml
  workflows/
    backup.yaml
```

--------------------------------

### Example Project Structure

Source: https://github.com/dagucloud/dagu/blob/main/specs/001-project.md

Illustrates a typical project layout including the .dagu.json configuration file, a workflows directory, and a scripts directory for executable files.

```text
project/
  .dagu.json
  workflows/
    deploy.yaml
  scripts/
    deploy.sh
```

--------------------------------

### Install Dagu Globally

Source: https://github.com/dagucloud/dagu/blob/main/npm/dagu/README.md

Installs the Dagu CLI globally on your system. Ensure to set `--ignore-scripts=false` to run the postinstall script for binary download.

```bash
npm install -g --ignore-scripts=false @dagucloud/dagu
```

--------------------------------

### Install Dagu Helm Chart from Local Source

Source: https://github.com/dagucloud/dagu/blob/main/charts/dagu/README.md

Install the Dagu Helm chart directly from a local source checkout. Replace `<your-rwx-storage-class>` with your cluster's ReadWriteMany storage class.

```bash
helm install dagu ./charts/dagu --set persistence.storageClass=<your-rwx-storage-class>
```

--------------------------------

### Install Dagu with Homebrew

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Install Dagu using the Homebrew package manager.

```sh
brew install dagu
```

--------------------------------

### Valid Step Output Reference Example

Source: https://github.com/dagucloud/dagu/blob/main/specs/007-value-resolution-steps.md

Demonstrates a valid reference to a step output. The 'deploy' step depends on 'build' and uses its 'image' output.

```yaml
steps:
  - id: build
    run: |
      printf 'image=v1.2.3\n' >> "$DAGU_OUTPUT_FILE"
    outputs:
      - name: image

  - id: deploy
    depends: build
    run: ./deploy.sh ${steps.build.outputs.image}
```

--------------------------------

### Create a Dagu Workflow File

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Example of a simple Dagu workflow file named 'hello.yaml' that prints 'hello from Dagu'.

```yaml
steps:
  - id: hello
    run: echo "hello from Dagu"
```

--------------------------------

### Start Dagu Server, Scheduler, and Coordinator

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/cli.md

Starts the Dagu server, scheduler, and optionally the coordinator in a single process. The coordinator is enabled by default. Use flags to specify host, port, and DAG directory.

```sh
dagu start-all [--host/-s <host>] [--port/-p <port>] [--dags/-d <dir>]
```

--------------------------------

### Start All Dagu Services

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Command to start all Dagu services. Access the UI at http://localhost:8080.

```sh
dagu start-all
```

--------------------------------

### Add and Install Dagu Helm Chart

Source: https://github.com/dagucloud/dagu/blob/main/charts/dagu/RELEASE.md

Commands to add the Dagu Helm repository, update it, and install the Dagu chart. Ensure you replace `<your-rwx-storage-class>` with your specific storage class.

```bash
helm repo add dagu https://dagucloud.github.io/dagu
helm repo update
helm install dagu dagu/dagu --set persistence.storageClass=<your-rwx-storage-class>
```

--------------------------------

### Workflow Definition Example

Source: https://github.com/dagucloud/dagu/blob/main/specs/001-project.md

A sample YAML file defining a 'deploy' workflow with a single step that executes a shell script.

```yaml
steps:
  - name: deploy
    run: ./scripts/deploy.sh
```

--------------------------------

### Install Main Dagu Package

Source: https://github.com/dagucloud/dagu/blob/main/npm/dagu-darwin-arm64/README.md

Install the main Dagu package, which will automatically include this platform-specific binary as an optional dependency.

```bash
npm install @dagucloud/dagu
```

--------------------------------

### New Context Initialization

Source: https://github.com/dagucloud/dagu/blob/main/refactor_persis_layer.html

Initializes various data stores using the file backend for persistence. This setup is used within the NewContext function.

```go
drs := file.NewDAGRunStore(cfg, ...)
ds  := file.NewDAGStore(cfg, ...)
qs  := store.NewQueueStore(file.NewCollection(cfg.Paths.QueueDir))
ps  := file.NewProcStore(cfg)
sr  := file.NewServiceRegistry(cfg)
leaseCollection := file.NewCollectionWithLockRoot(filepath.Join(distributedDir, "leases"), distributedDir)
activeRunCollection := file.NewCollectionWithLockRoot(filepath.Join(distributedDir, "active-runs"), distributedDir)
dls := store.NewDAGRunLeaseStore(leaseCollection)
ads := store.NewActiveDistributedRunStore(activeRunCollection)
dts := store.NewDispatchTaskStore(file.NewCollection(distributedDir))
us  := store.NewUserStore(file.NewCollection(cfg.Paths.UsersDir), ...)
ss  := store.NewSecretStore(file.NewCollection(cfg.Paths.SecretsDir), encryptor)
```

--------------------------------

### Install Dagu with Windows PowerShell

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Install Dagu on Windows using PowerShell.

```powershell
irm https://raw.githubusercontent.com/dagucloud/dagu/main/scripts/installer.ps1 | iex
```

--------------------------------

### Single Agent Step Example

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/codingagent.md

Defines a single agent step with parameters, harness configuration, and the agent's action.

```yaml
params:
  - PROMPT: "Explain the main function in this project"

harness:
  provider: claude
  model: sonnet
  bare: true

steps:
  - id: run_agent
    action: harness.run
    with:
      prompt: "${PROMPT}"
    output: RESULT
```

--------------------------------

### Install Dagu for Local Testing (ReadWriteOnce)

Source: https://github.com/dagucloud/dagu/blob/main/charts/dagu/README.md

Install the Dagu Helm chart for local testing environments like Kind or Docker Desktop that do not support ReadWriteMany (RWX) access modes. Sets access mode to ReadWriteOnce and skips validation.

```bash
helm install dagu dagu/dagu \
  --set persistence.accessMode=ReadWriteOnce \
  --set persistence.skipValidation=true \
  --set workerPools.general.replicas=1
```

--------------------------------

### Copy Example DAG to Kubernetes Server Pod

Source: https://github.com/dagucloud/dagu/blob/main/deploy/k8s/README.md

Copies an example DAG file to the Dagu server pod in Kubernetes for testing distributed execution. Alternatively, it shows how to create the DAG file directly on the server.

```bash
# Get the server pod name
SERVER_POD=$(kubectl get pod -n dagu-dev -l component=server -o jsonpath='{.items[0].metadata.name}')

# Copy example DAG
kubectl cp deploy/k8s/example-dag.yaml dagu-dev/$SERVER_POD:/var/lib/dagu/dags/test-distributed.yaml

# Or create directly
kubectl exec -n dagu-dev $SERVER_POD -- sh -c 'cat > /var/lib/dagu/dags/test-distributed.yaml' < deploy/k8s/example-dag.yaml
```

--------------------------------

### Start Dagu Coordinator

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/cli.md

Starts the gRPC coordinator for distributed execution. Specify the coordinator host and port, and peer options.

```sh
dagu coordinator [--coordinator.host/-H <host>] [--coordinator.port/-P <port>] [--peer.*]
```

--------------------------------

### Clone Dagu Repository and Start Backend Server

Source: https://github.com/dagucloud/dagu/blob/main/ui/README.md

Clone the Dagu repository and start the backend server. The server defaults to 127.0.0.1:8080. Modify configuration for different addresses or ports.

```bash
git clone git@github.com:dagucloud/dagu.git
cd dagu
make server
```

--------------------------------

### Start Dagu Server

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/cli.md

Starts the Dagu web UI and REST API. Options include specifying the host, port, DAG directory, and enabling tunneling.

```sh
dagu server [--host/-s <host>] [--port/-p <port>] [--dags/-d <dir>] [--tunnel/-t]
```

--------------------------------

### Install Dagu as a Project Dependency

Source: https://github.com/dagucloud/dagu/blob/main/npm/dagu/README.md

Installs Dagu as a dependency within your project. Use `--ignore-scripts=false` to enable the postinstall script for binary retrieval.

```bash
npm install --ignore-scripts=false @dagucloud/dagu
```

--------------------------------

### Valid JSON Output Example

Source: https://github.com/dagucloud/dagu/blob/main/specs/012-step-outputs.md

Shows a step publishing a JSON output 'metadata' and how it's referenced and printed in a subsequent step.

```yaml
steps:
  - id: inspect
    run: |
      cat >> "$DAGU_OUTPUT_FILE" <<'EOF'
      metadata<<JSON
      {"image":"api","tag":"v1.2.3"}
      JSON
      EOF
    outputs:
      - name: metadata
        type: json

  - id: print
    depends: inspect
    run: printf '%s\n' '${steps.inspect.outputs.metadata}'
```

--------------------------------

### Install Dagu Workflow Authoring Skill

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Install the Dagu workflow authoring skill for AI coding tools using the GitHub CLI.

```sh
gh skill install dagucloud/dagu dagu
```

--------------------------------

### Run Dagu with Docker

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Start Dagu using Docker, mounting a local directory for persistence and exposing the default port.

```sh
docker run --rm -v ~/.dagu:/var/lib/dagu -p 8080:8080 ghcr.io/dagucloud/dagu:latest dagu start-all
```

--------------------------------

### Environment Variable Resolution Example

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/env.md

Demonstrates how environment variables can reference parameters. Parameter resolution occurs before environment variable resolution, allowing for dynamic configuration.

```yaml
params:
  base: /tmp
env:
  - ROOT: "${base}"
  - OUTPUT_DIR: "${ROOT}/out"
```

--------------------------------

### Valid String Output Example

Source: https://github.com/dagucloud/dagu/blob/main/specs/012-step-outputs.md

Demonstrates a step publishing a string output 'image_tag' which is then used in a subsequent step's command.

```yaml
steps:
  - id: build
    run: |
      printf 'image_tag=v1.2.3\n' >> "$DAGU_OUTPUT_FILE"
    outputs:
      - name: image_tag

  - id: deploy
    depends: build
    run: ./deploy.sh ${steps.build.outputs.image_tag}
```

--------------------------------

### Dagu Project Configuration File

Source: https://github.com/dagucloud/dagu/blob/main/specs/001-project.md

Example of a `.dagu.json` file. This file defines project-specific settings like the directory for workflow files and the default working directory for workflow steps.

```json
{
  "workflows": "workflows",
  "working_dir": "."
}
```

--------------------------------

### Execute a DAG

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/cli.md

Use the 'dagu start' command to execute a DAG. It accepts various flags to customize the execution, such as parameters, run ID, and labels.

```sh
dagu start [flags] <dag> [-- params...]
```

--------------------------------

### Run Minimal Docker Compose Stack

Source: https://github.com/dagucloud/dagu/blob/main/deploy/docker/README.md

Starts the lightweight Docker Compose stack for local experiments. This includes the scheduler, worker, and UI.

```bash
docker compose -f deploy/docker/compose.minimal.yaml up -d
```

--------------------------------

### Dagu Sub-DAGs Example

Source: https://github.com/dagucloud/dagu/blob/main/internal/agent/system_prompt.txt

Illustrates how to run other DAGs as sub-tasks within a DAG. This includes sequential execution with parameters and parallel execution using the `parallel.items` construct.

```yaml
steps:
  - id: sub_task
    action: dag.run
    with:
      dag: child-workflow
      params:
        input_file: /data/input.csv

  - id: fan_out
    action: dag.run
    with:
      dag: worker
    parallel:
      items: ["A", "B", "C"]
```

--------------------------------

### Simplified Context Wiring (AFTER)

Source: https://github.com/dagucloud/dagu/blob/main/refactor_persis_layer.html

Demonstrates the simplified wiring of persistence components in cmd/context.go after the refactoring. It shows how a single Backend interface replaces numerous individual constructors.

```go
// context.go — NewContext()
backend := file.NewBackend(cfg.Paths)
ps := backend.Collection(proc.CollectionName)

```

--------------------------------

### Run Distributed Execution with Coordinator

Source: https://github.com/dagucloud/dagu/blob/main/examples/embedded/README.md

Run a Dagu DAG against an existing Dagu coordinator. This example starts an embedded worker and dispatches a DAG. Set DAGU_COORDINATORS for multiple coordinators and consider TLS for production.

```sh
DAGU_COORDINATORS=127.0.0.1:50055 go run ./examples/embedded/distributed
```

--------------------------------

### Build Binary

Source: https://github.com/dagucloud/dagu/blob/main/CONTRIBUTING.md

Run this command to build the Dagu binary.

```bash
make bin
```

--------------------------------

### File-based Store Implementation (Before)

Source: https://github.com/dagucloud/dagu/blob/main/refactor_persis_layer.html

This excerpt shows the original file-based implementation for fetching the latest DAG run attempt, involving extensive directory traversal and file I/O.

```Go
func (s *Store) LatestAttempt(
  ctx context.Context, name string,
) (exec.DAGRunAttempt, error) {
  // navigate directory tree...
  root := s.dagRunRootDir(name)
  dirs, err := os.ReadDir(root)
  if err != nil { ... }
  // sort, find latest, open file...
  for _, d := range dirs {
    aDir := filepath.Join(root, d.Name(), "attempt")
    files, _ := os.ReadDir(aDir)
    // parse filenames, check timestamps...
    for _, f := range files {
      data, _ := os.ReadFile(
        filepath.Join(aDir, f.Name()),
      )
      // unmarshal JSONL, pick last line...
    }
  }
  // ... 40 more lines of file wrangling
```

--------------------------------

### Start Dagu Coordinator

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Starts the Dagu coordinator service. This is the central management component for distributed task execution.

```sh
dagu coordinator
```

--------------------------------

### Basic Dagu Step Execution Example

Source: https://github.com/dagucloud/dagu/blob/main/internal/agent/system_prompt.txt

A simple Dagu workflow demonstrating sequential step execution using `run` for shell commands and `depends` for ordering. Step IDs must follow specific naming conventions.

```yaml
steps:
  - id: fetch_data
    run: curl -o data.json https://api.example.com/data
  - id: process
    run: python process.py
    depends:
      - fetch_data
  - id: notify
    run: echo "Done"
    depends:
      - process

```

--------------------------------

### Install Dagu with macOS/Linux Script

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Use this command to install Dagu on macOS or Linux systems using a curl script.

```sh
curl -fsSL https://raw.githubusercontent.com/dagucloud/dagu/main/scripts/installer.sh | bash
```

--------------------------------

### Start Dagu Scheduler

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/cli.md

Starts the Dagu cron scheduler, which monitors DAGs and triggers runs. Specify the DAG directory.

```sh
dagu scheduler [--dags/-d <dir>]
```

--------------------------------

### Dagu-Owned Reference Examples

Source: https://github.com/dagucloud/dagu/blob/main/specs/003-value-resolution.md

These are examples of Dagu-owned references that can be used in workflow YAML. They include constants, parameters, environment variables, and step outputs.

```text
${consts.name}
```

```text
${params.name}
```

```text
${env.NAME}
```

```text
${steps.step_id.outputs.name}
```

--------------------------------

### Client GET Request with remoteNode

Source: https://github.com/dagucloud/dagu/blob/main/ui/CLAUDE.md

Demonstrates how to add the `remoteNode` parameter to a GET request using the Dagu client. This ensures the request is routed to the correct remote node.

```typescript
// GET request
const response = await client.GET('/endpoint/{name}', {
  params: { path: { name: id }, query: { remoteNode } },
});
```

--------------------------------

### Build UI Bundle.js File

Source: https://github.com/dagucloud/dagu/blob/main/ui/README.md

Build the bundle.js file for the frontend assets. This file is copied to the Go backend for inclusion within the binary.

```bash
cd ../
make ui
```

--------------------------------

### Process Object-Form Output from Command

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/SKILL.md

This example shows how to capture command output, decode it as JSON, and select specific fields to be used as step outputs. It also demonstrates how to use these outputs in subsequent steps.

```yaml
steps:
  - id: inspect_build
    run: echo '{"version":"v1.2.3","artifact":{"url":"https://example.test/app.tgz"}}'
    output:
      # decode + select act as a lightweight contract check:
      # malformed JSON or a missing selected field fails the step.
      version:
        from: stdout
        decode: json
        select: .version
      artifact:
        from: stdout
        decode: json
        select: .artifact

  - id: publish
    depends: [inspect_build]
    output:
      versionLabel: "ver - ${inspect_build.output.version}"
      artifactUrl: "${inspect_build.output.artifact.url}"
```

--------------------------------

### Start Dagu Worker

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/cli.md

Starts a distributed worker for Dagu. Configure worker ID, max active runs, labels, and coordinator addresses. Peer options are also available.

```sh
dagu worker [--worker.id/-w <id>] [--worker.max-active-runs/-m <n>] [--worker.labels/-l <k=v,...>] [--worker.coordinators <addrs>] [--peer.*]
```

--------------------------------

### Dagu Action Caller Example

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/references/dagu-action.md

This example shows how to call Dagu actions within a workflow. It includes a notification action and a subsequent action that depends on the first and uses its output.

```yaml
steps:
  - id: notify
    action: acme/dagu-action-notify@v1.2.0
    with:
      text: "Build ${BUILD_ID} finished"

  - id: audit
    depends: [notify]
    run: echo "Message ID: ${notify.outputs.messageId}"
```

--------------------------------

### Start Dagu Worker with Labels

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Starts a Dagu worker process. Workers execute tasks assigned by the coordinator. Labels can be used to route specific DAGs to workers with matching capabilities.

```sh
DAGU_WORKER_LABELS=gpu=true,memory=64G dagu worker
```

--------------------------------

### Dagu Retry and Continue Policy Example

Source: https://github.com/dagucloud/dagu/blob/main/internal/agent/system_prompt.txt

Shows how to configure retry policies for steps, specifying the number of retries and the interval between them. It also demonstrates how to use `continue_on` to proceed with the workflow even if a step fails.

```yaml
steps:
  - id: flaky_step
    run: curl http://api.example.com/data
    retry_policy:
      limit: 3
      interval_sec: 10
    continue_on:
      failed: true
```

--------------------------------

### Run Linting and Tests

Source: https://github.com/dagucloud/dagu/blob/main/CONTRIBUTING.md

Execute these commands to run all Go unit and integration tests, and to perform linting.

```bash
make lint
make test
```

--------------------------------

### Build and load local Dagu image for kind

Source: https://github.com/dagucloud/dagu/blob/main/deploy/k8s/README.md

Builds a local Docker image for Dagu and loads it into a kind cluster named 'dagu-test'.

```bash
# Build local image
docker build -t dagu:local .

# Load into cluster (for kind/k3d)
kind load docker-image dagu:local --name dagu-test
```

--------------------------------

### Step Output Declaration Example

Source: https://github.com/dagucloud/dagu/blob/main/specs/012-step-outputs.md

Declares an output named 'image_tag' for a step. This is a YAML structure.

```yaml
steps:
  - id: build
    outputs:
      - name: image_tag
```

--------------------------------

### Collection-based Store Implementation (After)

Source: https://github.com/dagucloud/dagu/blob/main/refactor_persis_layer.html

This excerpt demonstrates the refactored implementation using a `persis.Collection` interface for fetching the latest DAG run attempt. It abstracts away direct file system operations.

```Go
type Store struct {
  col persis.Collection // "dag_runs"
}

func (s *Store) LatestAttempt(
  ctx context.Context, name string,
) (exec.DAGRunAttempt, error) {
  page, err := s.col.List(ctx, persis.ListQuery{
    Prefix: name + "/",
    Limit:  1,
  })
  if err != nil { return nil, err }
  if len(page.Records) == 0 {
    return nil, exec.ErrDAGRunIDNotFound
  }
  var status exec.DAGRunStatus
  json.Unmarshal(page.Records[0].Data, &status)
  return &attempt{status: status}, nil
}

// Testable with any mock Collection.
// Zero file-system dependencies.
```

--------------------------------

### Build Frontend Assets

Source: https://github.com/dagucloud/dagu/blob/main/CONTRIBUTING.md

Run this command to build the frontend assets for the Dagu project.

```bash
make ui
```

--------------------------------

### Check Pod Events

Source: https://github.com/dagucloud/dagu/blob/main/deploy/k8s/README.md

Use this command to inspect events related to a specific pod, which can help diagnose why it's not starting.

```bash
# Check pod events
kubectl describe pod -n dagu-dev -l app=dagu
```

--------------------------------

### Dagu Lifecycle Hooks Example

Source: https://github.com/dagucloud/dagu/blob/main/internal/agent/system_prompt.txt

Demonstrates how to define lifecycle hooks for steps, including init, success, failure, and exit handlers. These hooks allow custom commands to run at specific points in a step's execution.

```yaml
handler_on:
  init:
    run: echo "starting"
  success:
    run: echo "succeeded"
  failure:
    run: echo "failed with status ${DAG_RUN_STATUS}"
  exit:
    run: echo "always runs"
```

--------------------------------

### Define Params, Template Step, and Artifacts

Source: https://github.com/dagucloud/dagu/blob/main/skills/dagu/SKILL.md

This snippet shows how to define parameters for a skill, use the template.render action to generate dynamic content, and capture the output as an artifact.

```yaml
params:
  type: object
  properties:
    name:
      type: string
      maxLength: 50
    age:
      type: integer
      minimum: 0
      maximum: 120
    favorite_color:
      type: string
  required: [name, age]

steps:
  - id: render
    action: template.render
    with:
      data:
        name: ${name}
        age: ${age}
        favorite_color: ${favorite_color}
      template: |
        Hello, {{ .name }}!
        You are {{ .age }} years old.
        {{- if .favorite_color }}
        Your favorite color is {{ .favorite_color }}.
        {{- end }}
    stdout:
      artifact: greeting.txt
```

--------------------------------

### Dagu Workflow Step Definition

Source: https://github.com/dagucloud/dagu/blob/main/README_SCHEMA.md

Example of a Dagu step definition, showcasing common control fields and the execution field.

```yaml
steps:
  - id: step_id
    run: echo hello
    depends: [previous_step]
    env:
      - LOG_LEVEL: info
    timeout_sec: 300
    retry_policy:
      limit: 2
      interval_sec: 5
    output: RESULT
```

--------------------------------

### Build and Test Dagu Project

Source: https://github.com/dagucloud/dagu/blob/main/README.md

Clone the repository and use make commands to build the project, run tests with race detection, or perform linting.

```sh
git clone https://github.com/dagucloud/dagu.git && cd dagu
make build    # Build frontend + Go binary
make test     # Run tests with race detection
make lint     # Run golangci-lint
```

--------------------------------

### Force a Specific Image Tag

Source: https://github.com/dagucloud/dagu/blob/main/charts/dagu/README.md

Override the default image tag with a specific version. This example sets the tag to '2.2.4'.

```yaml
image:
  tag: 2.2.4
```

--------------------------------

### Show Dagu Configuration Paths

Source: https://github.com/dagucloud/dagu/blob/main/internal/agent/system_prompt.txt

Displays the resolved paths for DAGs directory, logs, and data. Use this to verify your Dagu setup.

```bash
dagu config                      # show resolved paths (DAGs dir, logs, data)
```

--------------------------------

### Disable Dagu Authentication

Source: https://github.com/dagucloud/dagu/blob/main/charts/dagu/README.md

Install the Dagu Helm chart with authentication disabled by setting `auth.mode` to 'none'. Requires specifying the storage class.

```bash
helm install dagu dagu/dagu \
  --set persistence.storageClass=<your-rwx-storage-class> \
  --set auth.mode=none
```

--------------------------------

### Build and load local Dagu image for k3d

Source: https://github.com/dagucloud/dagu/blob/main/deploy/k8s/README.md

Builds a local Docker image for Dagu and loads it into a k3d cluster named 'dagu-test'.

```bash
# Build local image
docker build -t dagu:local .

# Load into cluster (for kind/k3d)
k3d image import dagu:local --cluster dagu-test
```