Skip to content
/ CLI Public

DoPlan CLI is a revolutionary command-line tool that transforms how you start new projects. Instead of spending hours setting up project structure, configuring IDEs, writing boilerplate, and setting up CI/CD, DoPlan generates a complete, production-ready project with a full hierarchical AI agency system in under 5 seconds.

doplan.dev
1 star 0 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

DoPlan-dev/CLI

BranchesTags

Repository files navigation

██████╗░░█████╗░██████╗░██╗░░░░░░█████╗░███╗░░██╗ ██╔══██╗██╔══██╗██╔══██╗██║░░░░░██╔══██╗████╗░██║ ██║░░██║██║░░██║██████╔╝██║░░░░░███████║██╔██╗██║ ██║░░██║██║░░██║██╔═══╝░██║░░░░░██╔══██║██║╚████║ ██████╔╝╚█████╔╝██║░░░░░███████╗██║░░██║██║░╚███║ ╚═════╝░░╚════╝░╚═╝░░░░░╚══════╝╚═╝░░╚═╝╚═╝░░╚══╝

Zero-install AI Project Director - Bootstrap production-ready projects with a complete hierarchical AI agency system in seconds.

Version License Node.js Go CI Branch Policy NPM Downloads GitHub Stars GitHub Issues

Installation • Quick Start • Documentation • Features • Contributing

🚀 DoPlan CLI

✨ What is DoPlan CLI?

DoPlan CLI is a revolutionary command-line tool that transforms how you start new projects. Instead of spending hours setting up project structure, configuring IDEs, writing boilerplate, and setting up CI/CD, DoPlan generates a complete, production-ready project with a full hierarchical AI agency system in under 5 seconds.

🎯 Perfect For

  • Solo Developers who want to focus on building, not configuration
  • Small Teams looking to standardize their development workflow
  • Professionals who need production-ready project structures from day one
  • Anyone who wants to leverage AI agents for faster development

🌟 Key Features

  • ⚡ Zero-Install: Run with npx - no global installation needed
  • 🤖 18 AI Agents: Complete hierarchical agency (Product Manager, Engineers, Designers, QA, etc.)
  • 📚 1000+ Rules Library: Embedded best practices for all major tech stacks
  • 🎨 Interactive TUI: Beautiful terminal interface built with Bubbletea
  • 🔌 IDE-Agnostic: Supports 6 AI-powered IDEs (Cursor, Claude Code, Antigravity, Windsurf, Cline, OpenCode)
  • 🚀 Complete Automation: Project structure, agents, commands, rules, CI/CD, and boilerplate
  • 📦 Offline-First: Works completely offline after first run
  • 🔓 Transparent: All AI logic lives in markdown files - see and modify everything

📈 KPIs & Targets

  • Adoption: 10,000+ projects created in first 6 months
  • Engagement: Average 5+ commands used per project
  • Retention: 30%+ users create second project
  • Community: 100+ GitHub stars, active discussions
  • Quality: < 1% bug reports, 4.5+ star rating
  • Performance: 95%+ of projects generated in < 5 seconds

Generated via /github info. The helper caches metadata in Docs/history/github-meta.json, so KPI data stays available even when you're offline.

📦 Installation

Prerequisites

  • Node.js >= 14.0.0 (for npx wrapper)
  • Go >= 1.23.0 (only if building from source)

Quick Install (Recommended)

The easiest way to use DoPlan CLI is via npx - no installation required!

npx @doplan-dev/cli

This will automatically download the correct binary for your platform and run it.

Platform-Specific Installation

🍎 macOS

Option 1: Using Homebrew (Recommended)

# Add tap (if needed)
brew tap doplan-dev/cli

# Install
brew install doplan

Option 2: Using npx (No Installation)

npx @doplan-dev/cli

Option 3: Direct Binary Download

  1. Visit GitHub Releases
  2. Download doplan-darwin-amd64 (Intel) or doplan-darwin-arm64 (Apple Silicon)
  3. Make it executable: 
    chmod +x doplan-darwin-amd64
mv doplan-darwin-amd64 /usr/local/bin/doplan

Option 4: Build from Source

git clone https://github.com/DoPlan-dev/CLI.git
cd CLI
go build -o doplan ./cmd/doplan
sudo mv doplan /usr/local/bin/
🪟 Windows

Option 1: Using Scoop (Recommended)

scoop bucket add doplan https://github.com/DoPlan-dev/scoop-bucket.git
scoop install doplan

Option 2: Using npx (No Installation)

npx @doplan-dev/cli

Option 3: Direct Binary Download

  1. Visit GitHub Releases
  2. Download doplan-windows-amd64.exe
  3. Rename to doplan.exe and add to your PATH

Option 4: Build from Source

git clone https://github.com/DoPlan-dev/CLI.git
cd CLI
go build -o doplan.exe ./cmd/doplan
# Add to PATH or use from current directory
🐧 Linux

Option 1: Using npx (No Installation - Recommended)

npx @doplan-dev/cli

Option 2: Direct Binary Download

# Download latest release
curl -L https://github.com/DoPlan-dev/CLI/releases/latest/download/doplan-linux-amd64 -o doplan

# Make executable
chmod +x doplan

# Move to PATH
sudo mv doplan /usr/local/bin/

Option 3: Build from Source

git clone https://github.com/DoPlan-dev/CLI.git
cd CLI
go build -o doplan ./cmd/doplan
sudo mv doplan /usr/local/bin/

Option 4: Using Package Managers

Debian/Ubuntu:

# Download .deb package from releases (when available)
wget https://github.com/DoPlan-dev/CLI/releases/latest/download/doplan_amd64.deb
sudo dpkg -i doplan_amd64.deb

Arch Linux:

# Using AUR (when available)
yay -S doplan-cli
🐳 Docker 
docker run --rm -it -v $(pwd):/workspace doplan/cli

Verify Installation

After installation, verify it works:

doplan --version

You should see the version number (e.g., doplan version 1.0.4).

🚀 Quick Start

1. Create Your First Project

npx @doplan-dev/cli

This launches an interactive wizard that will:

  1. Ask for your project name
  2. Let you choose your preferred IDE
  3. Generate a complete project structure

2. Open Your Project

cd your-project-name
code .  # or your preferred IDE

3. Start Building

Once in your IDE, start using DoPlan commands:

/tell      → Capture your project idea
/improve   → Brainstorm with the leadership team
/write     → Generate PRD + Architecture + Design System
/change    → Patch any planning doc with natural language updates
/good      → Approve & lock the plan
/plan      → Generate execution plan + task hierarchy
/build     → Start the next (or specific) task
/progress  → Check totals, current task, and what's next
/state     → Snapshot, list, diff, or restore project history
/finished  → Auto-commit, push, and move to the next task
/report    → Generate scan metadata + diffs
/feedback  → Log structured feedback entries

4. (Optional) Re-run the beginner access patch

The CLI now auto-applies this patch right after it scaffolds your project, guaranteeing .do/ plus the organized docs folders (e.g., docs/overview, docs/references, docs/tutorials, docs/history) are writable. If you later move the repo into a locked folder (or clone it on a different machine), rerun:

npx --yes @doplan-dev/cli goplan access all

You can also target a single path if you already have others set up:

npx --yes @doplan-dev/cli goplan access .do/system   # only system files
npx --yes @doplan-dev/cli goplan access docs         # only docs/

This script simply creates the required folders/files and fixes permissions—perfect for beginners who don't want to touch Go tooling.

📖 How to Use

Core Commands

DoPlan uses intuitive slash commands that work directly in your AI-powered IDE:

Project Planning Commands

  • /tell - Capture your project idea

    /tell I want to build a task management app with React and Node.js

  • /improve - Team brainstorm session

    /improve

    Activates Product, Engineering, Design, QA, Release, and Documentation leads to surface opportunities, blockers, and acceleration ideas. Outputs .plan/00_System/BRAINSTORM.md.

  • /write - Generate planning documents

    /write

    Generates PRD, Architecture, and Design System documents.

  • /change - Edit any document

    /change prd Add dark mode support
/change architecture Use PostgreSQL instead of MongoDB

  • /good - Approve & lock the plan

    /good

    Locks the current plan and enables task generation.

Development Commands

  • /plan - Generate execution plan + tasks

    /plan

    Synthesizes TASKS.md from the approved plan and scaffolds phase folders.

  • /build - Start coding

    /build        # Start next task
/build 3      # Start specific task

  • /progress - Show current progress

    /progress
go run scripts/progress/main.go --root .

    Runs the Go helper at scripts/progress/ to display totals plus the most recent .do/system/history delta (phase/task/branch/completed changes). Pass --json for machine-readable output.

  • /state - Manage state snapshots & rollbacks

    /state list
/state diff --json
/state restore --file state-20251124T120000Z.json --yes

    Wraps go run scripts/statehistory/main.go so you can inspect history, capture snapshots (before/after /build and /finished), and safely restore .do/system/history/active_state.json.

  • /finished - Mark task complete

    /finished

Feedback & Reporting Commands

  • /feedback - Log structured product/bug feedback

    /feedback bug "QR download fails" "API returns 500 when Accept header missing" --author QA

    Saves to Docs/history/feedback.md (human readable) and Docs/history/feedback.json (consumed by automation).

  • /report - Generate scan metadata + diffs

    /report                       # current project
/report ./test/qr-generator/test-no01

    Runs go run scripts/scanreport/main.go to update SCAN_REPORT_*.json, create SCAN_DIFF_<date>.md, and append both the latest state-history summary and an embedded /progress snapshot (phase, completion %, upcoming tasks). Use --preset exec or --preset detailed for alternate templates (exec view, detailed visuals + dependency audit). Customization:

    • Create .do/reports/config.json to set defaults: 
      {
  "preset": "exec",
  "sections": ["executive", "progress", "visuals", "state", "feedback"]
}
    • CLI flags override config; custom sections let you reorder or omit report blocks.

Team & Information Commands

  • /team - Show active agents and hierarchy

    /team

  • /load - Inject context into AI agents

    /load

Specialized Commands

  • /ship - Release management
  • /safe - Security audit
  • /cheap - Cost optimization

Complete Workflow Example

# 1. Create project
npx @doplan-dev/cli

# 2. Open in IDE
cd my-awesome-project
code .

# 3. In your IDE, start planning:
/tell I want to build a social media dashboard with real-time analytics

# 4. Brainstorm with the team
/improve

# 5. Generate planning documents
/write

# 6. Review and approve
/good

# 7. Generate execution plan + tasks
/plan

# 8. Start building
/build

# 9. Track progress
/progress

🧠 Command Workflow

  1. Capture & Align – Start with /tell to record the idea, then /improve to gather Product, Engineering, Design, QA, Release, and Documentation insights into IDEA.md and BRAINSTORM.md.
  2. Document & Approve – /write turns those insights into PRD/Architecture/Design System, /change lets you refine any doc, and /good locks the set so tasks can be generated.
  3. Create the Roadmap – /plan turns the approved documents into phased TASKS.md so every feature has context, acceptance criteria, and branch guidance.
  4. Build Loop – For each task: /state snapshot → /build → iterate with /progress as needed → /finished (auto commit/push) → /state snapshot again. This loop keeps history diffable and the task board honest.
  5. Operate & Ship – Keep everyone aligned with /report, /feedback, /team, and /load, harden the release with /safe + /cheap, and ship confidently with /ship, /github, and /branchci.

This end-to-end loop is generated with every project, so the same commands are available in Cursor, Claude Code, Windsurf, Antigravity, Cline, and OpenCode without extra setup.

📟 Command Catalog

Command Phase What it unlocks
/tell Strategy Capture project intent into .plan/00_System/IDEA.md
/improve Strategy Cross-functional brainstorm saved to .plan/00_System/BRAINSTORM.md
/write Strategy Generate PRD, Architecture, Design System
/change Strategy Patch any planning doc with natural language
/good Strategy Lock the planning set and advance to tasks
/plan Delivery Expand planning docs into phased TASKS.md
/build [id] Delivery Start the next (or specific) implementation task
/progress Delivery Summaries for total/completed tasks + upcoming work
/state Delivery Snapshot, diff, and restore .do/system/history/active_state.json
/finished Delivery Mark tasks complete, auto-commit, and push
/feedback <type> Operations Log bugs/features/questions into Docs/history/feedback.*
/report [path] Operations Generate SCAN_REPORT metadata + diffs
/ship Operations Release orchestration + versioning checklist
/safe Operations Security review + dependency risk scan
/cheap Operations Cost optimization playbook
/team Context Display the 18-agent hierarchy
/load <context> Context Inject extra domain knowledge for agents
/github Integrations Sync KPIs, prep issues/milestones, update cache
/branchci Integrations Regenerate per-branch workflow guardrails

👉 Looking for deeper explanations? See Docs/foundation/the-guide.md or the wiki pages for Commands and Workflow.

Project Structure

When you create a project, DoPlan generates:

my-project/
├── .cursor/
│   ├── agents/              # 18 AI agent personas
│   ├── commands/            # Command definitions
│   └── rules/               # 1000+ rules library
│       └── library/         # Tech stack rules
├── .do/
│   ├── 00_System/          # IDEA.md, PRD.md, ARCHITECTURE.md, DESIGN_SYSTEM.md
│   ├── TASKS.md            # Implementation tasks
│   ├── active_state.json   # Project state
│   └── history/            # Time-stamped snapshots for rollback + reports
├── Docs/                   # Optional capitalized docs (see test fixtures)
├── .github/
│   └── workflows/          # CI/CD automation
├── src/                    # Your source code
├── STANDUP.md             # Daily standup notes
└── README.md              # Project documentation

📑 Docs, Changelog & Wiki

  • CHANGELOG.md follows Keep a Changelog + SemVer. Check the latest entry before cutting a release or running /ship.
  • The Docs/ tree mirrors what every generated project should publish (foundation, features, release, history). Use it as the canonical structure reference.
  • The GitHub wiki stays in sync with this README—Commands, Workflow, Quick Start, and Troubleshooting are updated whenever the CLI changes.
  • Automation helpers such as /report, /feedback, /state, and /github info keep each of those artifacts aligned (KPI block, scan diffs, feedback logs, and state history).

🎯 Features

🤖 Hierarchical AI Agency

DoPlan includes 18 specialized AI agents:

  • Project Orchestrator (CEO/Engineering Manager)
  • Product Manager
  • Engineering Lead
  • System Architect
  • Frontend Lead & Backend Lead
  • DevOps Engineer
  • Security Lead
  • Design & UX Manager & UI/UX Designer
  • QA & Reliability Manager & QA Engineer
  • Release & Growth Manager & Release Captain & Growth Coach
  • Documentation Lead & Documentation Writer
  • Performance Engineer

Each agent has a specific role and expertise, working together to guide your project from idea to production.

📚 Comprehensive Rules Library

1000+ embedded rules covering:

  • Core workflows and best practices
  • AI agents and orchestration
  • Programming languages (Go, JavaScript, TypeScript, Python)
  • Frameworks (Next.js, React, Express)
  • UI libraries and design systems
  • Cloud infrastructure
  • Databases (PostgreSQL, MongoDB)
  • Testing (Jest, Vitest, Go testing)
  • DevOps and CI/CD
  • Code quality and linting
  • Documentation standards
  • Security practices
  • MCP tools integration

🕒 State History & Rollback

  • .do/system/history/state-*.json stores every update to active_state.json, captured automatically around /build and /finished
  • /state (backed by go run scripts/statehistory/main.go) lets you snapshot, list, diff, or restore with confirmation guardrails
  • /progress and /report surface the latest history diff so stakeholders always know what changed (phase, task, branch, completed tasks)

🎨 Beautiful Interactive TUI

Built with Bubbletea, DoPlan's terminal interface is:

  • Fast and responsive
  • Visually appealing
  • Keyboard-friendly
  • Accessible

🔌 Multi-IDE Support

Works seamlessly with:

  • Cursor (Recommended)
  • Claude Code
  • Antigravity
  • Windsurf
  • Cline
  • OpenCode

🚀 Complete Automation

DoPlan generates:

  • ✅ Project structure
  • ✅ AI agent system
  • ✅ Command definitions
  • ✅ Rules library
  • ✅ GitHub Actions workflows (CI/CD, releases, changelog)
  • ✅ IDE configuration files
  • ✅ Boilerplate code
  • ✅ Documentation templates

📚 Documentation

Getting Started

Guides

Reference

Contributing

🤝 Contributing

We welcome contributions! Whether it's:

  • 🐛 Reporting bugs
  • 💡 Suggesting features
  • 📝 Improving documentation
  • 🔧 Submitting pull requests
  • ⭐ Giving us a star

Every contribution helps make DoPlan better for everyone.

See our Contributing Guide for details.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

  • Bubbletea - Beautiful TUI framework
  • Cobra - CLI framework
  • Lipgloss - Styling library
  • All our amazing contributors and users

🔗 Links

Made with ❤️ by the DoPlan Team

⭐ Star us on GitHub • 🐛 Report Bug • 💡 Request Feature • 📖 Documentation

About

DoPlan CLI is a revolutionary command-line tool that transforms how you start new projects. Instead of spending hours setting up project structure, configuring IDEs, writing boilerplate, and setting up CI/CD, DoPlan generates a complete, production-ready project with a full hierarchical AI agency system in under 5 seconds.

doplan.dev

Topics

cli workflow documentation-tool planning developer-tools agents github-workflow

Resources

Readme
Activity
Custom properties

Stars

1 star

Watchers

1 watching

Forks

0 forks
Report repository

Releases 4

Release v1.2.0 Latest
Nov 27, 2025
+ 3 releases

Packages

No packages published

Languages