Landing

<title>Vibe Action</title>

<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<meta property="og:title" content="Vibe Action" />
<meta
  property="og:description"
  content="Command router for shell and LLM tasks via YAML pipelines"
/>

<link rel="icon" href="assets/images/favicon.png" />

# Quick Start
## 1. Install Ollama (or DeepSeek)
## 2. Install Vibe Action
cargo install vibe-action
## 3. AI-powered commit
vibe-action commit -p .
## 4. Translate fast
vibe-action translate-small -f README.md
## 5. Translate deep
vibe-action translate-large -f README.md








© 2026 Vibe Action










  

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 — 20+ inline value transformations with arguments
• 🔀 When/Then — conditional execution in YAML without shell scripts
• 🌳 AST parsing — {tag|ast} auto-detects language from file, {tag|ast:rs} for explicit
• 🖥️ System tags — 15 built-in tags: {system_clipboard}, {system_dir_pwd}, {system_os} and more
• 👁️ Vision support — screenshot description, person identification, image from URL or clipboard
• 🌐 Fetch — load and summarize web pages, PDFs, images via load and text modifiers
• 📦 Scan — scan codebase and export AST as structured JSON
• 🧪 Benchmarks — automatic testing of all actions with timing and output validation
• ⚡ Action cache — instant startup via snapshot-based validation
• 🤖 Batch LLM — parallel execution across cluster nodes with role-based routing (tiny, small, medium, large, vision)
• ✅ Type-safe — validate outputs with expect: string | list and regex check
• 🔔 Notifications — optional desktop notifications on completion
• 🔐 Confirmations — ask before executing dangerous commands
• 💬 Self-documenting — built-in faq command answers questions about Vibe Action itself
• 🎯 CLI-first — no browser, no context switching. Everything in the terminal
• 🔌 IDE Integration — built-in api block for seamless VS Code and IntelliJ plugin support
• ⏱️ Process Guard — new runs automatically supersede previous ones, keeping state predictable
• 🔒 Open & Flexible — open source. Use local models via Ollama or cloud APIs (DeepSeek, Qwen, Kimi, Zhipu)
• 🦀 Fast — built in Rust

Key Concepts

YAML Pipelines

Describe your workflow in YAML, not code:

name: extract
about: Extract matching lines from text and logs
args:
  - name: file
    short: f
    input: string
    help: Path to the log or text file
  - name: query
    short: q
    input: string
    help: Extraction criteria (e.g., 'find all errors')
actions:
  - tag: tag_lines
    run: cmd
    expect: list
    action: cat {file}
  - tag: tag_content
    run: small
    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|uniq|join}'

When/Then Conditions

Use when/then for conditional logic without shell scripts:

- 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:

- tag: tag_info
  run: value
  expect: string
  action: |
    User: {system_user}
    OS: {system_os}
    PWD: {system_dir_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

Getting Started

Prerequisites

• Ollama (recommended), or API keys for DeepSeek, Qwen, Kimi, or Zhipu — for LLM inference
• Rust (if building from source)

Supported Platforms

• macOS — full support
• Linux — full support

Install Ollama

# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh

# Pull models for different roles
ollama pull qwen2.5-coder:3b-instruct   # small
ollama pull qwen2.5-coder:7b-instruct   # medium
ollama pull qwen2.5-coder:14b-instruct  # large
ollama pull qwen2.5vl:7b                # vision

Install Vibe Action

Via Cargo (recommended)

cargo install vibe-action

Build from source

git clone https://gitcode.com/keygenqt_vz/vibe-action.git
cd vibe-action
cargo build --release

First Run

On first run, Vibe Action creates the config and default actions:

$ vibe-action --help

This creates:

• ~/.vibe-action/config.yaml — configuration
• ~/.vibe-action/actions/ — 21 built-in actions

Configure Cluster

Edit ~/.vibe-action/config.yaml to point to your Ollama instance:

version: '0.0.3'

action:
  system: 'You are Vibe Action — a CLI tool. Output ONLY the result.'
  retries: 2

cluster:
  - provider: ollama
    host: http://localhost:11434
    model: qwen2.5-coder:14b-instruct
    timeout_secs: 60
    temperature: 0.1
    seed: 42
    num_ctx: 4096
    num_predict: 2048
    parallel: 1

Run Your First Actions

# AI-powered commit
vibe-action commit -p .

# Translate a file
vibe-action translate-small -f README.md
vibe-action translate-large -f README.md

# Rewrite tone from clipboard
vibe-action tone

# Extract errors from logs
vibe-action extract -f app.log -q "find all errors"

# Describe a screenshot
vibe-action describe -f screenshot.png

# Fetch and summarize a web page
vibe-action fetch -s https://example.com

# System report
vibe-action sysinfo

# Scan project codebase as JSON
vibe-action scan

# Ask about Vibe Action itself
vibe-action faq -q "как использовать модификаторы?"

# Check version and status
vibe-action status

# Clear all cache
vibe-action clean

# Stop all running processes
vibe-action stop

# Run benchmarks
vibe-action bench
vibe-action bench -a faq -v

# See all available actions
vibe-action --help

Debug Mode

Set VIBE_LOG_TYPE=tracing VIBE_TRACE_LEVEL=debug to see what’s happening under the hood:

VIBE_LOG_TYPE=tracing VIBE_TRACE_LEVEL=debug vibe-action commit -p .

Shows each pipeline step: original command, resolved template, and result.

Next Steps

• Action Structure — learn the YAML format
• Built-in Actions — explore what’s included
• Custom Actions — write your own
• Tag System — understand {tag} references
• Modifiers — transform output with pipe modifiers
• System Tags — built-in environment variables

IDE Integration (VS Code & IntelliJ)

Vibe Action works perfectly from the terminal, but you can supercharge your workflow with the Vibe Action Cross IDE plugin.

Instead of manually configuring tasks.json in VS Code or External Tools in IntelliJ, the plugin provides a native UI panel inside your editor. It communicates directly with the vibe-action CLI to discover all available actions, letting you run them with visible, real-time feedback.

Why Use the Plugin?

• Zero Configuration: No need to edit JSON/XML files. The plugin automatically fetches all available actions from the vibe-action CLI — including built-in commands, your custom YAML flows, and any modifications you’ve made to the defaults.
• Context Awareness: Automatically passes selected text or clipboard content to your actions using the api block defined in your YAML manifests.
• Native UI: Get real-time progress feedback inside the IDE instead of waiting for terminal windows or system notifications.
• Seamless Output: Results can automatically replace selected code, be copied to the clipboard, or appear in a native dialog window.

Prerequisites

1. Vibe Action CLI must be installed and available on your system PATH.

   cargo install vibe-action
   

2. Get the plugin: Download the latest pre-built artifacts (.vsix and .zip) directly from the dist directory on GitCode, or build them yourself from the vibe-action-cross repository source.

VS Code Setup

1. Open VS Code.
2. Go to the Extensions view (Cmd+Shift+X or Ctrl+Shift+X).
3. Click the ... menu in the top-right corner of the Extensions panel.
4. Select Install from VSIX….
5. Navigate to the downloaded file and select vibe-action-0.0.1.vsix.
6. Reload VS Code when prompted.

Alternatively, install via CLI:

code --install-extension vibe-action-0.0.1.vsix

Once installed, open the Vibe Action panel from the activity bar. You will see a list of all your available actions. Click any action to run it, or use the provided keyboard shortcuts.

IntelliJ IDEA Setup

1. Open IntelliJ IDEA.
2. Go to Settings/Preferences -> Plugins.
3. Click the gear icon (⚙️) in the top-right corner of the Plugins window.
4. Select Install Plugin from Disk….
5. Navigate to the downloaded file and select vibe-action-plugin-0.0.1.zip.
6. Restart IntelliJ IDEA when prompted.

Once installed, open the Vibe Action tool window (usually located on the right sidebar). The UI is rendered natively using Compose Multiplatform and matches the IntelliJ theme.

How It Works: The api Block

The vibe-action CLI exposes the optional api block from your YAML actions, which the plugin uses to determine how to handle inputs and outputs. If you are creating custom actions or modifying built-in ones, you can define this block to make them IDE-friendly.

name: upper
about: Convert text to UPPERCASE
api:
  output: replace # How to output: replace | clipboard | dialog
  args:
    text: selection # Where to get input: selection | clipboard
args:
  - name: text
    short: t
    input: string
    default: '{system_clipboard}'
actions:
  - tag: tag_upper
    run: value
    expect: string
    action: '{text|upper}'

Output Targets

• replace: The plugin will replace the currently selected text in your editor with the action’s result.
• clipboard: The result will be silently copied to your system clipboard.
• dialog: The result will be shown in a native IDE popup/dialog.

Input Contexts

• selection: The plugin will automatically grab the text you currently have highlighted in the editor and pass it to the argument.
• clipboard: The plugin will pass the contents of your system clipboard to the argument.

If an action does not have an api block, the plugin will simply execute it and fall back to standard CLI behavior (usually copying to clipboard).

Action Structure

Each action is a YAML file in ~/.vibe-action/actions/. The engine loads all .yaml files recursively and builds a CLI command for each one.

Minimal Action

name: hello
about: Say hello
actions:
  - tag: tag_hello
    run: value
    expect: string
    action: Hello, World!

$ vibe-action hello
info: completed in 0.01s
── success ──
Hello, World!
─────────────

Full Structure

name: my-action # CLI subcommand name
about: Description # Help text
check: '^[a-z]+$' # Optional: regex validation for final output
notify: true # Optional: show system notification on completion
args: # Optional: CLI arguments
  - name: input
    short: i
    input: string # string | bool | number | path | list<string> | list<bool> | list<number> | list<path>
    help: Input text
    default: 'default' # Optional: makes argument non-required
api: # Optional: IDE plugin integration
  output: replace # replace | clipboard | dialog
  args:
    input: selection # selection | clipboard
actions: # Pipeline steps (executed in order of dependencies)
  - tag: tag_step1
    run: cmd # cmd | value | small | medium | large | vision | tiny
    expect: string # string | list. Omit for no expected output.
    check: '^.+$' # Optional: regex validation for this step
    confirm: true # Optional: ask before executing
    action: echo "Hello {input}!"

Action Types

Argument Types (input)

Expect Types

Omit expect for steps with no expected output.

IDE Plugin Integration (api)

The optional api block configures how IDE plugins (like VS Code or IntelliJ) interact with the action.

• output: Defines how the final result is presented (replace selected text, send to clipboard, or show in a dialog).
• args: Maps action arguments to IDE contexts (e.g., automatically pass the selection or clipboard to the argument).

Conditional Actions (When/Then)

action can be a list of when/then pairs for conditional execution:

- 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."

Each when condition is evaluated. The first matching then is executed. If no condition matches — the step fails with an error.

Execution Order

Actions are sorted by their {tag} dependencies, not by their order in the file. The engine builds a dependency graph and executes in topological order.

actions:
  - tag: tag_files # 1st — no dependencies
    run: cmd
    action: find . -name '*.rs'

  - tag: tag_summary # 2nd — depends on tag_files
    run: small
    action: Summarize - {tag_files}

Check (Regex Validation)

check validates output against a regex pattern. If the output doesn’t match — the step fails with an error.

- tag: tag_files
  run: cmd
  check: '.+' # Must be non-empty
  action: git diff --name-only

Confirm

confirm: true asks the user for approval before executing. Useful for dangerous commands.

- tag: tag_commit
  run: cmd
  confirm: true
  action: git commit -m "feat: something"

Clipboard

Use the clipboard modifier to copy values during pipeline execution:

- tag: tag_result
  run: value
  expect: string
  action: '{tag_data|format:json|clipboard}'

Tag System

Tags connect pipeline steps. When you write {tag_name} in an action, the engine replaces it with the output of the step that has tag: tag_name.

Basic Example

actions:
  - tag: tag_files
    run: cmd
    expect: list
    action: ls *.rs

  - tag: tag_summary
    run: small
    expect: string
    action: Summarize these files - {tag_files|join}

Step tag_summary depends on tag_files. The engine runs tag_files first, then passes its output to tag_summary. The |join modifier collapses the list result into a single string — without it, tag_summary would execute once for each file in the list.

Automatic Dependency Ordering

You don’t need to write steps in execution order. The engine:

1. Scans all actions for {tag} references
2. Builds a directed acyclic graph (DAG)
3. Sorts topologically using Kahn’s algorithm
4. Detects circular dependencies and reports errors

actions:
  # These can be in any order — the engine sorts them:
  - tag: tag_commit
    run: cmd
    action: git commit -m '{tag_message}'

  - tag: tag_files
    run: cmd
    action: git diff --name-only

  - tag: tag_message
    run: small
    action: Write a commit message for: {tag_files}

Execution order: tag_files → tag_message → tag_commit

List Expansion

When a step expects string or runs cmd but receives a list from a tag, the engine runs the action for each element:

actions:
  - tag: tag_files
    run: cmd
    expect: list
    action: git diff --name-only
    # Returns: ["main.rs", "lib.rs"]

  - tag: tag_diff
    run: cmd
    expect: list
    action: git diff {tag_files}
    # Runs twice: git diff main.rs, git diff lib.rs
    # Returns: ["diff for main", "diff for lib"]

Multiple Dependencies

A step can reference multiple tags:

- tag: tag_report
  run: small
  expect: string
  action: |
    Compare these two files:
    File A: {tag_file_a}
    File B: {tag_file_b}

The engine waits for both tag_file_a and tag_file_b before running tag_report.

Escaping Literals

Use {{...}} to include literal braces that should not be parsed as tags:

- tag: tag_example
  run: value
  expect: string
  action: |
    To reference a tag, use {{tag_name}} syntax in your action.
    The modifier {{tag|upper}} transforms text to UPPERCASE.

Circular Dependencies

Circular references are detected at startup and reported as errors:

# ❌ This will fail validation:
- tag: tag_a
  action: echo {tag_b}
- tag: tag_b
  action: echo {tag_a}

Error: Circular dependency detected involving tag: 'tag_a'

Invalid Modifiers

Using a pipe | without specifying a modifier name (e.g., {tag|}) will cause a fatal validation error, and the pipeline will halt immediately. Always ensure modifiers are properly named (e.g., {tag|upper}) or remove the pipe.

Modifiers

Modifiers transform tag values inline: {tag|modifier} or {tag|modifier:argument}. All modifiers work with both strings and lists.

Summary Table

Escape Mnemonics

Use these codes in modifier arguments to bypass YAML whitespace trimming:

Example: {tag|join:,\s} → ", " (comma-space).

Predicate Modifiers

Return "true"/"false" as strings for when conditions. Invert with :not:

{tag|empty:not}
{tag|contains:x:not}
{tag|is_file:not}

Chaining

{tag|uniq|trim|upper|join:,\s}
{tag|split|take:3|join}
{tag|empty:not}

Escaping Literals

Use {{...}} to include literal braces:

# Literal, not a tag:
{{name}}
{{tag|upper}}

System Tags

System tags are built-in variables available in any flow. They provide context from your environment without requiring CLI arguments.

Available Tags

Usage

System tags can be used anywhere in your flow — actions, arguments, and conditions:

actions:
  - tag: tag_info
    run: value
    expect: string
    action: |
      User: {system_user}
      OS: {system_os}
      PWD: {system_dir_pwd}

args:
  - name: query
    short: q
    input: string
    default: '{system_clipboard}'

- tag: tag_result
  run: cmd
  expect: string
  action:
    - when: '{system_os|equals:macos}'
      then: echo "Running on macOS"

Notes

• System tags are read-only and cannot be modified by flow steps.
• {system_clipboard} is read once at flow startup. If clipboard changes during execution, the tag still holds the original value.
• {system_language} returns the language code from LANG env (ru_RU.UTF-8 → ru). Falls back to en if not set.

Built-in Actions

Vibe Action ships with 21 ready-to-use actions. They are written to ~/.vibe-action/actions/ on first run and can be customized.

comment

Replace TODO with a meaningful comment.

vibe-action comment

commit

AI-generated git commit message with conventional commit format.

vibe-action commit
vibe-action commit -p ./src

describe

Describe a screenshot or photo. Supports images from clipboard, file, or URL.

vibe-action describe -f screenshot.png
vibe-action describe

explain

Explain what the selected code does by adding detailed comments.

vibe-action explain -q "your code"
vibe-action explain

extract

Extract matching lines from log files or text using semantic search.

vibe-action extract -f app.log -q "find all errors"

faq

Ask questions about Vibe Action — YAML structure, modifiers, usage.

vibe-action faq -q "как использовать модификаторы?"

fetch

Fetch and summarize a web page or PDF.

vibe-action fetch -s https://example.com
vibe-action fetch -s document.pdf

find

Semantic file finder — finds files by meaning, not just by name.

vibe-action find -p ./src -q "topological sort"

mock

Generate realistic mock data in JSON, YAML, or CSV.

vibe-action mock -f json -q "5 users with id, name, email"

naming

Generate code naming suggestions based on a description.

vibe-action naming -q "function to sort actions by dependency"

regex

Generate regular expression patterns.

vibe-action regex -q "IPv4 address" -e "192.168.1.1"

review

Critically analyze code for bugs and flaws.

vibe-action review -q "your code"
vibe-action review

scan

Scan project codebase and export as structured JSON via AST parsing.

vibe-action scan
vibe-action scan -p src/engine

spellcheck

Check and fix spelling in text or files.

vibe-action spellcheck -f README.md
vibe-action spellcheck -t "Helo, wrld!"

synonyms

Find programming/technical synonyms for a word.

vibe-action synonyms -q "middleware"

sysinfo

Generate a human-readable system report.

vibe-action sysinfo

tone

Transform rude or aggressive text into a professional tone.

vibe-action tone -q "How fucking long do I have to wait?"
vibe-action tone

translate-deep

Deep two-stage translation using local drafting and cloud polishing.

vibe-action translate-deep -f README.md

translate-large

One step translation using a large model.

vibe-action translate-large -f README.md

translate-small

Fast single-model translation.

vibe-action translate-small -f README.md

whois

Identify people in a photo — full name, role, and historical impact.

vibe-action whois -f photo.jpg
vibe-action whois

Custom Actions

Create your own actions by adding .yaml files to ~/.vibe-action/actions/. Any subdirectory works — the engine loads all files recursively.

Hello World

name: hello
about: Say hello
actions:
  - tag: tag_hello
    run: value
    expect: string
    action: Hello, World!

Shell Command

name: disk
about: Show disk usage
actions:
  - tag: tag_disk
    run: cmd
    expect: string
    action: df -h /

With Arguments

name: greet
about: Greet someone
args:
  - name: name
    short: n
    input: string
    help: Name to greet
    default: World
actions:
  - tag: tag_greeting
    run: value
    expect: string
    action: Hello, {name}!

Using System Tags

System tags provide context from your environment. See System Tags for the full list.

actions:
  - tag: tag_info
    run: value
    expect: string
    action: |
      User: {system_user}
      OS: {system_os}
      PWD: {system_dir_pwd}
      Date: {system_date}

LLM Call

args:
  - name: query
    short: q
    input: string
actions:
  - tag: tag_answer
    run: small
    expect: string
    action: |
      Explain this concept in simple terms:
      {query}

Vision Call

args:
  - name: image
    short: f
    input: string
    default: '{system_clipboard_image}'
actions:
  - tag: tag_description
    run: vision
    expect: string
    action: |
      {image|load|text}

      Describe this image in detail.

Fetch Web or PDF

args:
  - name: source
    short: s
    input: string
actions:
  - tag: tag_description
    run: small
    expect: string
    action: |
      Summarize this document:
      {source|load|text}

Scan Codebase

name: my-scan
about: Scan project codebase as JSON
args:
  - name: path
    short: p
    input: string
    default: .
actions:
  - tag: tag_validate
    run: cmd
    expect: string
    action:
      - when: '{path|is_dir}'
        then: echo "{path}"
      - when: '{path|is_dir:not}'
        then: echo "'{path}' is not a directory" && exit 1
  - tag: tag_resolve
    run: value
    expect: string
    action: '{tag_validate|resolve}'
  - tag: tag_ast
    run: value
    expect: list
    action: '{tag_resolve|scan|ast:brief}'
  - tag: tag_json
    run: value
    expect: string
    action: '{tag_ast|format:json}'

IDE Integration (VS Code / IntelliJ)

Define how IDE plugins should handle your action using the api block. This example replaces the selected text with its uppercase version:

name: upper
about: Convert text to UPPERCASE
api:
  output: replace # replace | clipboard | dialog
  args:
    text: selection # automatically pass selected text to 'text' arg
args:
  - name: text
    short: t
    input: string
    default: '{system_clipboard}'
actions:
  - tag: tag_upper
    run: value
    expect: string
    action: '{text|upper}'

Clipboard

Use the clipboard modifier to copy values at any pipeline step:

- tag: tag_copy
  run: value
  expect: string
  action: '{tag_data|format:json|clipboard}'

Conditional Actions (When/Then)

actions:
  - tag: tag_changed
    run: cmd
    expect: list
    action: git diff --name-only

  - tag: tag_commit
    run: cmd
    expect: string
    action:
      - when: '{tag_changed|empty:not}'
        then: git add . && git commit -m "auto: updates"
      - when: '{tag_changed|empty}'
        then: echo "Nothing to commit."

Multi-Step Pipeline

actions:
  - tag: tag_content
    run: cmd
    expect: string
    action: cat {file}

  - tag: tag_summary
    run: small
    expect: string
    action: |
      Summarize this file in 2-3 sentences:
      {tag_content}

Tips

• Tag naming: use tag_ prefix for consistency with built-in actions
• Dependencies: the engine sorts steps by {tag} references, not YAML order
• Validation: add check: ".+" to ensure non-empty output
• Debugging: set VIBE_LOG_TYPE=tracing VIBE_TRACE_LEVEL=debug to see each step’s input and output
• Clipboard: use {tag|clipboard} to copy any value to clipboard mid-pipeline
• Images: use {image|load|text} for vision flows — works with files, URLs, and clipboard
• System tags: see System Tags for all available environment variables
• Notifications: add notify: true to show desktop notification on completion

Configuration

Vibe Action uses a single YAML config file at ~/.vibe-action/config.yaml. It is created automatically on first run.

Action

Runtime settings for all flows.

action:
  system: |
    You are Vibe Action — a CLI tool, not a chatbot.
    Work fast. Don't think too much. Just do the task.
    Output ONLY the requested result.
  retries: 2

Cluster

Define one or more LLM providers. The engine sends prompts to all nodes in parallel. Use role to assign models to specific complexity levels.

cluster:
  - provider: ollama
    host: http://localhost:11434
    model: qwen2.5-coder:14b-instruct
    role: medium
    timeout_secs: 60
    temperature: 0.1
    seed: 42
    num_ctx: 4096
    num_predict: 2048
    parallel: 1

Cluster Node Fields

Multi-Node Cluster with Roles

cluster:
  - provider: ollama
    host: http://localhost:11434
    model: qwen2.5-coder:3b-instruct
    role: tiny
    timeout_secs: 30
    temperature: 0.0
    seed: 42
    num_ctx: 4096
    num_predict: 512
    parallel: 2

  - provider: zhipu
    host: https://open.bigmodel.cn/api/paas/v4
    model: glm-4-flash
    role: small
    timeout_secs: 60
    temperature: 0.1
    seed: 42
    num_ctx: 8192
    num_predict: 2048
    api_key: sk-...
    parallel: 2

  - provider: ollama
    host: http://192.168.1.10:11434
    model: qwen2.5-coder:14b-instruct
    role: medium
    timeout_secs: 60
    temperature: 0.1
    seed: 42
    num_ctx: 8192
    num_predict: 2048
    parallel: 1

  - provider: deepseek
    host: https://api.deepseek.com/v1
    model: deepseek-v4-flash
    role: large
    timeout_secs: 120
    temperature: 0.1
    seed: 42
    num_ctx: 16384
    num_predict: 8192
    api_key: sk-...
    parallel: 2

  - provider: kimi
    host: https://api.moonshot.cn/v1
    model: moonshot-v1-8k
    role: large
    timeout_secs: 120
    temperature: 0.1
    seed: 42
    num_ctx: 8192
    num_predict: 2048
    api_key: sk-...
    parallel: 1

  - provider: ollama
    host: http://localhost:11434
    model: qwen2.5vl:7b
    role: vision
    timeout_secs: 120
    temperature: 0.1
    seed: 42
    num_ctx: 4096
    num_predict: 2048
    parallel: 1

Nodes with role: tiny are used for run: tiny, role: small for run: small, role: medium for run: medium, role: large for run: large, role: vision for run: vision. Nodes without a role respond to all requests.

Actions Directory

Actions are stored in ~/.vibe-action/actions/. The directory is created on first run with default actions. Override with VIBE_ACTION_PATH.

~/.vibe-action/
├── config.yaml
└── actions/
    ├── comment.yaml
    ├── commit.yaml
    ├── describe.yaml
    ├── explain.yaml
    ├── ...

Add your own .yaml files here — they will be loaded automatically.

CLI Reference

Environment Variables

Output Modes

Trace Levels

Note: VIBE_TRACE_LEVEL is only respected when VIBE_LOG_TYPE is set to tracing. Using it with other modes will cause an error.

Commands

Execute a YAML-defined action directly:

vibe-action <name> [args...]
vibe-action commit -p .
vibe-action translate-small -f README.md -l Russian
vibe-action tone   # reads from clipboard
vibe-action --help

System commands:

vibe-action clean              # Remove all cache and temp files
vibe-action status             # Show version and actions count
vibe-action stop               # Stop all running processes
vibe-action bench              # Run all benchmarks
vibe-action bench -a faq -v    # Run benchmarks for specific action with output

Action Arguments

Each action defines its own arguments in YAML. Use --help to see available options:

vibe-action commit --help
vibe-action extract --help

Exit Codes

Debug Mode

Set VIBE_LOG_TYPE=tracing and VIBE_TRACE_LEVEL=debug (or trace) for detailed logs:

VIBE_LOG_TYPE=tracing VIBE_TRACE_LEVEL=debug vibe-action commit -p .

Shows:

• Original and resolved action text
• Shell command output
• LLM prompts and responses