vibe-action 0.0.3

Command router — execute shell commands and LLM prompts via simple YAML actions.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

# Introduction

Vibe Action is a command router that executes shell commands and LLM prompts via simple YAML pipelines.

## Why Vibe Action

- ⚡ **One command = complex pipeline** — chain shell scripts and LLM calls into a single action
- 🔗 **Tag system** — connect steps via `{tag}` references with automatic dependency graph
- 🔧 **Modifiers** — rich set of modifiers with arguments for transforming values inline
- 🔀 **When/Then** — conditional execution in YAML without shell scripts
- 🌳 **AST parsing** — `{tag|ast:rs}` extract code structure for smarter prompts
- 🖥️ **System tags** — `{system_clipboard}`, `{system_pwd}`, `{system_os}` and more
- 🤖 **Batch LLM** — parallel execution across cluster nodes with role-based routing
- ✅ **Type-safe** — validate outputs with types and regex
- 🔔 **Notifications** — optional desktop notifications on completion
- 🔐 **Confirmations** — ask before executing dangerous commands
- 🎯 **CLI-first** — no browser, no context switching. Everything in the terminal
- 🔒 **Local & free** — open source, local models via Ollama. No subscriptions
- 🦀 **Fast** — built in Rust

## Key Concepts

### YAML Pipelines

Describe your workflow in YAML, not code:

```yaml
name: extract
about: Extract matching lines from text and logs
args:
  - name: file
    short: f
    expect: string
    help: Path to the log or text file
  - name: query
    short: q
    expect: string
    help: Extraction criteria (e.g., 'find all errors')
actions:
  - tag: tag_lines
    run: cmd
    expect: list<string>
    action: cat {file}
  - tag: tag_content
    run: llm
    expect: string
    action: |
      [Task]
      If the line matches the query — output the EXACT line unchanged.
      If it does not match — output only a single dash: "-"
      Do NOT skip lines. Process every line.

      [Query]
      {query}

      [Line]
      {tag_lines}
  - tag: tag_clean
    run: value
    expect: string
    action: '{tag_content|trim:-}'
  - tag: tag_extract
    run: value
    expect: string
    action: '{tag_clean|join:uniq}'
```

### When/Then Conditions

Use `when/then` for conditional logic without shell scripts:

```yaml
- tag: tag_result
  run: cmd
  expect: string
  action:
    - when: '{tag_check|contains:DIRTY}'
      then: echo "{tag_content}"
    - when: '{tag_check|contains:CLEAR}'
      then: echo "No errors found."
```

### System Tags

Access environment context anywhere in your pipelines:

```yaml
- tag: tag_info
  run: value
  expect: string
  action: |
    User: {system_user}
    OS: {system_os}
    PWD: {system_pwd}
    Date: {system_date}
```

## How It Works

1. **You write a YAML file** describing your workflow — steps, types, dependencies
2. **The engine parses it** and builds a dependency graph from `{tag}` references
3. **Steps execute in order** — shell commands run locally, LLM prompts go to your cluster
4. **Results are validated** against expected types and optional regex patterns
5. **Final output** is displayed on screen, copied to clipboard, or sent as notification