miyabi-cli

Status: Stable Category: Tool

Overview

Miyabi CLI - 一つのコマンドで全てが完結。The command-line interface for the Miyabi autonomous AI development platform. Provides comprehensive workflow automation, agent orchestration, and project management capabilities.

Features

• Agent Orchestration: Execute all 21 Miyabi agents from command line
• Workflow Automation: Parallel and sequential task execution
• Mode Management: Infinity, parallel, and interactive modes
• Git Worktree Integration: Automatic worktree lifecycle management
• Knowledge Base: Qdrant-powered knowledge search and retrieval
• Status Monitoring: Real-time workflow and agent status tracking
• Configuration Management: Flexible YAML/TOML/JSON configuration
• Interactive UI: Rich terminal interface with progress bars and tables

Installation

Quick Install (Recommended)

Using cargo-binstall for pre-built binaries:

cargo binstall miyabi-cli

Download Binary

# macOS (Apple Silicon)
curl -sSL https://github.com/ShunsukeHayashi/Miyabi/releases/latest/download/miyabi-aarch64-apple-darwin.tar.gz | tar xz
sudo mv miyabi /usr/local/bin/

# macOS (Intel)
curl -sSL https://github.com/ShunsukeHayashi/Miyabi/releases/latest/download/miyabi-x86_64-apple-darwin.tar.gz | tar xz
sudo mv miyabi /usr/local/bin/

# Linux (x86_64)
curl -sSL https://github.com/ShunsukeHayashi/Miyabi/releases/latest/download/miyabi-x86_64-unknown-linux-gnu.tar.gz | tar xz
sudo mv miyabi /usr/local/bin/

# Linux (ARM64)
curl -sSL https://github.com/ShunsukeHayashi/Miyabi/releases/latest/download/miyabi-aarch64-unknown-linux-gnu.tar.gz | tar xz
sudo mv miyabi /usr/local/bin/

Build from Source

# From crates.io
cargo install miyabi-cli

# From source
cd crates/miyabi-cli
cargo install --path .

Usage

Quick Start

# Initialize new project
miyabi init my-project

# Check system status
miyabi status

# Work on a GitHub Issue
miyabi work-on 123

# Execute agent
miyabi agent coordinator --issue 123

# Parallel execution
miyabi parallel --issues 123,124,125 --concurrency 3

# Infinity mode (process all open issues)
miyabi infinity

Commands

miyabi init

Initialize a new Miyabi project with configuration wizard.

miyabi init my-project
# Interactive prompts for:
# - GitHub repository
# - API keys
# - Agent configuration

miyabi work-on <issue>

Start working on a GitHub Issue with automatic worktree creation.

miyabi work-on 456
# Creates worktree at .worktrees/issue-456
# Switches to feature branch
# Ready for development

miyabi agent <type>

Execute a specific agent.

# Coordinator agent
miyabi agent coordinator --issue 123

# CodeGen agent
miyabi agent codegen --issue 124 --worktree .worktrees/issue-124

# Review agent
miyabi agent review --pr 125

miyabi parallel

Execute multiple tasks in parallel.

# Process 3 issues concurrently
miyabi parallel --issues 123,124,125 --concurrency 3

# With specific agents
miyabi parallel --issues 123,124 --agent codegen

miyabi infinity

Process all open GitHub Issues continuously.

miyabi infinity
# Fetches all open issues
# Assigns to agents based on labels
# Executes in parallel with max concurrency

miyabi status

Display current system status.

# One-time check
miyabi status

# Watch mode (updates every 5s)
miyabi status --watch

miyabi knowledge

Search and manage knowledge base.

# Search knowledge
miyabi knowledge search "error handling"

# Add entry
miyabi knowledge add --text "Best practice for..." --tags rust,error

miyabi config

Manage configuration.

# Show current config
miyabi config show

# Edit config
miyabi config edit

# Validate config
miyabi config validate

Configuration

Configuration File

Location: ~/.miyabi/config.yaml or project .miyabi.yml

# GitHub settings
github:
  token: ${GITHUB_TOKEN}
  repository: owner/repo
  device_identifier: MacBook

# Agent settings
agents:
  max_concurrency: 5
  timeout_seconds: 3600

# LLM settings
llm:
  provider: anthropic
  model: claude-sonnet-4-20250514
  api_key: ${ANTHROPIC_API_KEY}

# Worktree settings
worktree:
  base_path: .worktrees
  cleanup_on_completion: true

# Knowledge settings
knowledge:
  qdrant_url: http://localhost:6333
  collection_name: miyabi-knowledge

Environment Variables

# Required
export GITHUB_TOKEN="ghp_xxx"
export ANTHROPIC_API_KEY="sk-xxx"

# Optional
export OPENAI_API_KEY="sk-xxx"
export DEVICE_IDENTIFIER="MacBook"
export RUST_LOG="info"

Architecture

miyabi-cli
├── commands/          # Command implementations
│   ├── agent.rs       # Agent execution
│   ├── init.rs        # Project initialization
│   ├── parallel.rs    # Parallel execution
│   ├── status.rs      # Status monitoring
│   └── ...
├── agents/            # Agent integrations
├── config.rs          # Configuration management
├── display.rs         # Terminal UI
├── service.rs         # Core service layer
└── main.rs            # CLI entry point

Examples

Example 1: Complete Workflow

# 1. Initialize project
miyabi init my-ai-project

# 2. Check status
miyabi status

# 3. Work on issue
miyabi work-on 100

# 4. Generate code
cd .worktrees/issue-100
miyabi agent codegen --issue 100

# 5. Review changes
miyabi agent review --pr 101

# 6. Deploy
miyabi agent deploy --pr 101

Example 2: Parallel Processing

# Process multiple issues
miyabi parallel \
  --issues 100,101,102,103,104 \
  --concurrency 3 \
  --agent coordinator

# Output:
# ✓ Issue 100: Complete
# ✓ Issue 101: Complete
# ⏳ Issue 102: In Progress
# ...

Example 3: Knowledge Search

# Search for error handling patterns
miyabi knowledge search "async error handling in Rust"

# Results:
# 1. thiserror crate best practices (relevance: 0.95)
# 2. anyhow vs thiserror comparison (relevance: 0.87)
# 3. Custom error types example (relevance: 0.82)

Dependencies

• clap: Command-line argument parsing
• tokio: Async runtime
• dialoguer: Interactive prompts
• colored: Terminal colors
• indicatif: Progress bars
• comfy-table: Table formatting
• miyabi-agents: Agent implementations
• miyabi-orchestrator: Task orchestration
• miyabi-worktree: Worktree management
• miyabi-knowledge: Knowledge base

Development Status

• Basic functionality
• All commands implemented
• Agent integration
• Parallel execution
• Status monitoring
• Knowledge search
• Configuration management
• Tests
• Documentation
• Shell completions
• Plugin system

Shell Completions

Generate completions for your shell:

# Bash
miyabi completions bash > /usr/local/etc/bash_completion.d/miyabi

# Zsh
miyabi completions zsh > /usr/local/share/zsh/site-functions/_miyabi

# Fish
miyabi completions fish > ~/.config/fish/completions/miyabi.fish

Troubleshooting

Issue: Command not found

# Add cargo bin to PATH
export PATH="$HOME/.cargo/bin:$PATH"

Issue: Configuration not found

# Initialize configuration
miyabi init

# Or manually create
mkdir -p ~/.miyabi
cp .miyabi.example.yml ~/.miyabi/config.yaml

Related Crates

• miyabi-agents: All 21 agent implementations
• miyabi-orchestrator: Task orchestration engine
• miyabi-worktree: Git worktree management
• miyabi-knowledge: Qdrant knowledge base
• miyabi-core: Core utilities
• miyabi-types: Shared type definitions

License

Apache-2.0