@dewtech/dare-cli

CLI tool for the DARE Framework — Design, Architect, Review, Execute.

A structured methodology for AI-assisted software development with mandatory human-in-the-loop reviews and parallel task execution.

⚠ Read this first — How dare init runs the official scaffold

dare init invokes the official scaffold of the stack you pick. That means it literally runs:

| Stack | What dare init runs | |-------|----------------------| | php-laravel | composer create-project laravel/laravel:^11 . | | node-nestjs | npx @nestjs/cli new . --strict --skip-git | | python-fastapi | python -m venv .venv && python -m pip install -r requirements.txt | | rust-axum | cargo init + write Cargo.toml (axum, sqlx, tokio…) | | go-gin | go mod init + go get gin/godotenv + starter files | | go-stdlib | go mod init + starter usando só net/http (zero deps externas) | | react, vue | npx degit vitejs/vite/packages/create-vite/template-<x> . + npm install | | rust-leptos | Cargo workspace with crates/server (Axum) + crates/web (Leptos 0.7 SSR+hydrate) + cargo fetch | | rust-leptos-csr | Cargo workspace with crates/server (Axum) + crates/web (Leptos 0.7 CSR) + Trunk.toml + cargo fetch | | mcp-server-node-ts | npm init + @modelcontextprotocol/sdk | | mcp-server-python | python -m venv .venv + pip install mcp[cli] |

These need a working composer / npm / cargo / python / go somewhere. There are three ways to provide it — you pick at init time (prompt below), and the choice is saved in dare.config.json so dare bootstrap reuses it later.

? Toolchain for scaffolding (composer / npm / cargo / python / go):
  ❯ 🤖 Auto — use native if on PATH, else Docker (recommended)
    🔧 Native only — require the CLI on PATH (faster, no Docker pulls)
    🐳 Docker only — always use the official image (hermetic, no host install)

🤖 Auto (default)

Tries the native CLI first. If missing, falls back to the official Docker image automatically. If neither is present, fails fast with both install links.

which composer  → ✓ found?  use native
                → ✗ missing? which docker
                              → ✓ found?  docker run composer:latest …
                              → ✗ missing? error: install Composer or Docker

When: you don't know exactly what's installed; mixed teams (some machines have the toolchain, some only have Docker). The same project config (dare.config.json with toolchain: auto) works on every machine.

🔧 Native only

Requires the CLI on PATH. Fails immediately if missing — no Docker fallback even if Docker is available.

which composer → ✓ found?  use native
                → ✗ missing? error: "Install Composer: https://getcomposer.org/"

When: you already have the toolchain and want maximum speed (no docker pull, no bind-mount overhead, no container startup); you're in CI with the toolchain pre-installed; you want to avoid Docker Desktop edge cases (Windows volume throttling, Linux uid/gid issues, etc.).

🐳 Docker only

Always runs the scaffold inside the official Docker image — even if the native CLI is on PATH. Fails if Docker isn't installed.

which docker → ✓ found?  docker run --rm -v ".:/app" composer:latest create-project …
              → ✗ missing? error: "Install Docker Desktop"

When: you don't want to install PHP / Cargo / Python / Go on the host (keep host clean); you want hermetic, reproducible builds (every dev uses the exact toolchain version baked into the image); you want to mirror your CI locally.

Quick decision table

| Your situation | Pick | |----------------|------| | Already have the toolchain installed, want speed | 🔧 Native | | Don't want to install PHP/Cargo/Python/Go on the host | 🐳 Docker | | Mixed team, varying setups | 🤖 Auto | | Just want it to work | 🤖 Auto | | Want bit-for-bit toolchain reproducibility | 🐳 Docker | | Solo dev with everything installed | 🔧 Native |

Override later

dare bootstrap --toolchain docker          # rerun scaffold inside Docker
dare bootstrap --toolchain native --force  # rerun native, overwriting framework files
dare bootstrap --toolchain auto            # back to auto-detect

⚠ Important caveat — Ralph Loop

dare execute --complete runs the stack's quality gates (composer dump-autoload, php artisan test, cargo build, etc.) directly on the host — it does not automatically wrap them in Docker even if you picked docker only at init time.

If you don't have the native toolchain installed, the agent should run the gates inside the container created by task-001 (the Containerize task), e.g. docker compose exec app php artisan test. The skills shipped with dare init already nudge the agent toward that pattern.

Prerequisites

Required for the CLI itself

| Tool | Why | Install | |------|-----|---------| | Node.js 18+ | runs dare, dare-mcp-server and the bundled GraphRAG engine | https://nodejs.org/ |

Required to scaffold the chosen stack

dare init runs the official scaffold of the stack you pick (e.g. composer create-project laravel/laravel, npm create vite@latest, go mod init). It tries the native toolchain first; if it isn't on PATH, it falls back to running the equivalent Docker image automatically.

Pick one of the two paths per stack:

| Stack | Native toolchain | Docker fallback (used if native missing) | |-------|------------------|------------------------------------------| | php-laravel | PHP 8.2+ · Composer 2+ — https://getcomposer.org/ | composer:latest | | node-nestjs | Node 18+ (bundles npx) | node:20-alpine | | python-fastapi | Python 3.11+ — https://www.python.org/downloads/ | python:3.12-slim | | rust-axum | Rust 1.83+ (rustup) — https://www.rust-lang.org/tools/install | rust:1.83 | | go-gin | Go 1.25+ — https://go.dev/dl/ | golang:1.25 | | go-stdlib | Go 1.22+ — https://go.dev/dl/ | golang:1.25 | | react, vue | Node 18+ (bundles npm) | node:20-alpine | | rust-leptos | Rust 1.83+ (rustup) + cargo-leptos 0.2.22 — cargo install cargo-leptos --version 0.2.22 | ghcr.io/dewtech-technologies/dare-rust-leptos:1 | | rust-leptos-csr | Rust 1.83+ (rustup) + trunk — cargo install trunk | ghcr.io/dewtech-technologies/dare-rust-leptos:1 | | mcp-server-node-ts | Node 18+ | node:20-alpine | | mcp-server-python | Python 3.11+ | python:3.12-slim |

TL;DR: if you have Docker Desktop installed, you don't strictly need any other toolchain — dare init will pull the right image on demand. Native toolchains are faster and don't depend on Docker pulling images.

If neither the native CLI nor Docker is available, dare init fails fast with a clear error message — it never falls back to a fake template.

Choose the toolchain at init time

The 3 modes (auto / native / docker) are explained in detail at the top of this README — see ⚠ Read this first.

Quick recap:

| Mode | Behavior | |------|----------| | auto (default) | Native if available, else Docker. Recommended. | | native | Requires the native CLI; fails if missing. | | docker | Always uses the official Docker image. |

The choice is persisted in dare.config.json ("toolchain": "..."). Override at any time:

dare bootstrap --toolchain docker          # rerun scaffold inside Docker
dare bootstrap --toolchain native --force  # rerun native, overwriting

Required for the Ralph Loop (per project)

Once the project is scaffolded, every dare execute --complete runs the stack's gates: build → test → lint. The same toolchain (native or Docker) that scaffolded the project is needed to run those gates. Plan accordingly: if you chose php-laravel and only have Docker, dare execute --complete needs to invoke php artisan test somehow — typically by running it inside your docker-compose app service (this is the kind of thing the task-001 = Containerize app task sets up).

Installation

npm install -g @dewtech/dare-cli

Commands

dare init

Interactive project initialization — creates the full project structure with DARE methodology files, IDE rules and stack templates.

dare init my-project

Prompts:

• Structure: Monorepo · Backend only · Frontend only · MCP Server ← new
• MCP Server: language (TypeScript / Python), transport (stdio / SSE / HTTP Stream), capabilities (Tools / Resources / Prompts)
• Backend stack: Rust/Axum · Node.js/NestJS · Python/FastAPI · PHP/Laravel · Go/Gin · Go/stdlib
• Frontend stack: React 18+ · Vue 3+ · Leptos fullstack (Rust SSR+WASM) · Leptos CSR-only (Rust WASM)
• Cargo workspace layout (Monorepo + Rust/Axum + Leptos only): Single-crate (crates/server + crates/web) · Multi-crate ({prefix}-core + {prefix}-server + {prefix}-web + {prefix}-cli) — prefix suggested from project initials (e.g. ai-runtime-securyti-rasp → arsr)
• IDE / Agent: Claude Code · Cursor · Antigravity · Hybrid
• GraphRAG backend: SQLite · JSON · Neo4j
• DARE MCP Server: context query server (saves ~95% tokens)

Generates:

• dare.config.json — project config
• CLAUDE.md + .claude/commands/ + .claude/settings.json — Claude Code rules and slash commands (includes /dare-security)
• .cursorrules / .antigravityrules — Cursor / Antigravity rules
• .cursor/rules/*.mdc — stack-specific skills
• .cursor/commands/ — Cursor slash commands
• .agents/skills/ — Antigravity agent skills
• DARE/ — methodology directory (DESIGN, BLUEPRINT, TASKS, dag)
• Full project template ready to run (MCP server, backend or frontend)

dare discover ← new in v0.3.0

Detects an existing project's stack automatically and installs DARE files without touching your source code.

# Run inside an existing project
cd my-existing-project
dare discover

# Inspect only, no changes
dare discover --check

# Target a specific directory
dare discover --dir ./path/to/project

Auto-detects from: package.json, Cargo.toml, requirements.txt, pyproject.toml, composer.json.

Recognizes: NestJS · React · Vue · Nuxt · Rust/Axum · FastAPI · Laravel · MCP Server (@modelcontextprotocol/sdk, FastMCP).

dare design

Generate DARE/DESIGN.md from a project description.

dare design "Build a REST API for user authentication with JWT"

dare blueprint

Generate DARE/BLUEPRINT.md from DESIGN.md. Stops here — requires human review and approval before tasks are created.

dare blueprint

dare tasks

Generate DARE/TASKS.md, DARE/dare-dag.yaml and all DARE/EXECUTION/task-*.md specs from an approved BLUEPRINT.md. Run this only after reviewing and approving the blueprint.

dare tasks

dare execute

Orchestrate DAG execution. The IDE is the executor (Cursor / Antigravity / Claude Code) — dare execute only coordinates state, composes prompts with parent context, updates the live canvas at DARE/.canvas.md, and ingests finished tasks into the knowledge graph.

No API keys, no extra token costs. You use the plan of the IDE you're already logged into.

# Print next executable tasks (with composed prompts)
dare execute --next

# Mark a task DONE after the agent finishes it
dare execute --complete task-001 --output "Created src/auth.ts and tests/auth.test.ts; all tests green."

# Mark a task FAILED — descendants are cascade-skipped automatically
dare execute --fail task-002 --reason "Schema migration conflict in users table"

# Reset a task back to PENDING (for retry)
dare execute --reset task-002

# Show snapshot of canvas + summary (default action)
dare execute --status

Typical flow inside the IDE agent

dare execute --next                                # → tasks ready in current rank
# (agent executes each task: code, build, test, lint)
dare execute --complete task-001 --output "…"
dare execute --complete task-002 --output "…"
dare execute --next                                # → next rank
# (repeat until "✅ All tasks resolved")

The skills shipped by dare init (.cursor/rules/skill-dag-runner.mdc, .agents/skills/dare-dag-runner/SKILL.md, .claude/commands/dare-dag-run.md) guide the IDE agent through this loop.

Stack-specific skills

dare init also ships skills focused on architectural decisions for specific stacks. As of v2.15.0:

• skill-rust-workspace.mdc (Cursor) / dare-rust-workspace/SKILL.md (Antigravity) / /dare-rust-workspace (Claude command) — guides the agent on whether a Rust project should start single-crate or as a Cargo workspace, and gives a step-by-step PR-by-PR migration plan when an existing single-crate project has outgrown its layout. Active during /dare-design and /dare-blueprint for rust-axum projects, plus on demand for migration analysis.

• skill-rust-leptos.mdc (Cursor) / dare-rust-leptos/SKILL.md (Antigravity) / /dare-rust-leptos (Claude command) — full guide for Leptos development: CSR vs fullstack decision table, Leptos 0.7 idioms (signals, Resource, Action, Show, For, #[server]), shared types with cfg_attr, mixed workspace configuration (WASM + native crates), and antipatterns to avoid (cargo leptos test does not exist; no global [build] target in .cargo/config.toml). Ships 3 ready-to-use DARE task templates for Leptos projects.

dare bootstrap

Run the official scaffold for a project's stack on an existing project (created in older versions or with --skip-bootstrap). Reads dare.config.json and dispatches to:

• composer create-project laravel/laravel for php-laravel
• npx @nestjs/cli new for node-nestjs
• npm create vite for react / vue
• python -m venv + pip install for python-fastapi
• cargo init + axum-ready Cargo.toml for rust-axum
• npm init + @modelcontextprotocol/sdk for mcp-server-node

dare bootstrap          # refuses if vendor/ or node_modules/ already exist
dare bootstrap --force  # runs anyway (may overwrite framework files)

Your DARE artifacts (.cursor/, DARE/, dare.config.json, dare-graph.yml) are preserved.

dare info

Read-only diagnostic of the current project: CLI version, platform, presence of each canonical DARE artifact, active GraphRAG backend, and task progress.

dare info

dare review ← new in v2.17.0

Anti-stub gate. Audita os arquivos que uma task tocou e detecta padrões de "fake completeness": TODO/FIXME, stubs (throw new Error('not implemented'), todo!(), NotImplementedError), funções vazias, retorno-fantasma (return null como única statement), mocks fora de testes (jest.fn, vi.mock, sinon.stub, MagicMock), comentários-placeholder (// implement later).

A camada estática (regex, determinística) é só metade. A IDE agent pode rodar a skill dare-review / review-task para validar critério-a-critério se a implementação atende a spec, emitir um SemanticVerdict JSON, e o CLI funde os dois numa única decisão.

# Audita os arquivos listados em DARE/EXECUTION/task-034.md
dare review task-034

# Em CI:
dare review task-034 --strict --format json

# Lista explícita de arquivos:
dare review task-034 --files src/auth/login.ts src/auth/register.ts

# Funde com verdito semântico do agente:
dare review task-034 --from-agent .dare/verdict-task-034.json

Gate opt-in no Ralph Loop: com review.onComplete: true em dare.config.json, dare execute --complete <id> bloqueia DONE se a review falhar. Para projetos novos (dare init v2.17+) já vem ligado; projetos legados permanecem off até o dev flipar.

dare refine ← new in v2.17.0

Anti-monstro. Mede complexidade de uma task e, opcionalmente, propõe quebra em sub-tasks menores. Heurística determinística pesa # arquivos, # funções/endpoints, # testes, # dependências, keywords "pesadas" (refactor/migrate/integrate/multiple) — produz um score em LOW (0–5) / MED (6–12) / HIGH (13–20) / CRITICAL (21+).

# Apenas mede e reporta:
dare refine task-034

# Mede + propõe quebra em sub-tasks (task-034a, task-034b, ...):
dare refine task-034 --split

# Anota TASKS.md marcando a task para split (o agente regenera as specs):
dare refine task-034 --split --apply

# Em CI: exit code 2 se HIGH/CRITICAL:
dare refine task-034 --strict

A camada determinística agrupa arquivos por diretório raiz. A IDE agent (skills dare-refine / refine-task) refina o split semanticamente — por camada (Model/Controller/Service), por endpoint, por feature, refactor-then-feature, migration-then-code.

Thresholds configuráveis em dare.config.json:

{
  "refine": {
    "thresholds": { "low": 5, "med": 12, "high": 20 }
  }
}

dare update ← new in v2.17.0

Sync the project's DARE setup (templates, slash commands, skills, schema) with the version of the CLI currently installed. Useful when you upgrade the CLI globally (npm install -g @dewtech/dare-cli@latest) and want a previous project to pick up the new improvements — without touching your DESIGN / BLUEPRINT / TASKS / dare-dag.yaml artifacts.

Different from upgrading the CLI itself: npm update -g @dewtech/dare-cli changes the binary on your machine; dare update changes the project files on disk to match what that binary now ships.

dare update                  # interactive (recommended)
dare update --dry-run        # preview: shows changelog + affected files, writes nothing
dare update --yes            # CI: apply, preserve customizations, no prompts
dare update --force          # also overwrite files the dev customized (dangerous)
dare update --target 2.17.0  # update to a specific release instead of the installed CLI

What it does:

1. Reads version from dare.config.json (the project's last-known DARE version).
2. Loads templates/UPDATE-MANIFEST.json (ships with the CLI) and lists every release between the project's version and the CLI's version.
3. Prints the changelog for each pending release and the list of files affected for your IDE (cursor / claude-code / antigravity / hybrid).
4. For each file, classifies the situation:
   • identical → skip
   • missing → create
   • apply → file matches the previous template hash, safe to overwrite
   • customized → file diverges from the previous template; prompt (keep / replace) unless --yes (keep) or --force (replace).
5. Backs up every affected file to .dare/backup-<from-version>/ before writing.
6. Runs any schema migrations declared by the release (e.g. renaming a config field).
7. Stamps version and updatedAt in dare.config.json.

Adding entries when you cut a release: each new CLI version that ships template changes needs a corresponding entry in templates/UPDATE-MANIFEST.json listing changes (added / modified / removed / renamed) and optional migrations. The applier filters changes by appliesTo: [ide], so a template that's cursor-only won't be installed in a Claude Code project and vice versa.

dare validate

Static checks on dare-dag.yaml — ideal for pre-commit hooks and CI. Verifies unique kebab-case ids, valid depends_on, absence of cycles, non-empty prompts, and parallelism (warning when only one task at rank 0).

dare validate                # errors fail; warnings printed
dare validate --strict       # warnings also fail (CI-friendly)

A pre-commit hook template is shipped at templates/hooks/pre-commit-dare-validate — copy to .git/hooks/pre-commit (or use with husky) to validate the DAG before every commit.

dare execute --watch

Interactive loop: the CLI watches .dare/state.json and re-prints the next ready tasks every time the state changes. Pair with the IDE agent firing --complete/--fail from another terminal.

dare execute --watch

dare dag

Inspect and visualize the static task DAG declared in dare-dag.yaml — distinct from dare graph, which inspects the populated knowledge graph (only contains tasks already executed).

dare dag viz                              # Mermaid to stdout
dare dag viz -o DARE/dag-graph.mmd        # Mermaid file
dare dag viz -f dot -o DARE/dag-graph.dot # DOT (Graphviz)

The Mermaid output groups tasks into rank subgraphs and colors nodes by status (PENDING / RUNNING / DONE / FAILED / SKIPPED), so you can see the execution plan before running any task.

dare tasks writes DARE/dag-graph.mmd automatically — open it in your editor with a Mermaid preview to see the static graph immediately.

dare graph

Inspect the project's knowledge graph. The graph is populated automatically by dare execute --complete/--fail (task nodes, file nodes, depends_on and implements edges). Backend is whatever dare-graph.yml declares (sqlite default, json available, neo4j planned).

dare graph stats                       # totals + breakdown by type
dare graph query auth                  # search nodes by label/description
dare graph query auth --limit 20

dare graph viz                         # Mermaid to stdout
dare graph viz -f dot                  # DOT for Graphviz
dare graph viz -o docs/graph.mmd       # write to file

dare graph ingest                      # re-sync from dare-dag.yaml + state

Full Workflow

# New project
dare init my-project
cd my-project
dare design "Describe what you're building"
dare blueprint
dare execute --parallel

# Existing project
cd my-existing-project
dare discover
dare design "Describe what you're building"
dare blueprint
dare execute --parallel

Claude Code Workflow

dare init my-project
# → IDE: Claude Code
# → Structure: Backend / Frontend / MCP Server

cd my-project
# Claude Code slash commands available:
# /dare-design   → generates DARE/DESIGN.md
# /dare-blueprint → generates BLUEPRINT.md + DAG
# /dare-execute task-001 → implements with Ralph Loop
# /dare-tasks    → shows task status table

Files generated for Claude Code:

CLAUDE.md                    ← main context (stack rules + DARE methodology)
.claude/
  settings.json              ← permissions + Ralph Loop hook
  commands/
    dare-design.md           ← /dare-design
    dare-blueprint.md        ← /dare-blueprint
    dare-execute.md          ← /dare-execute
    dare-tasks.md            ← /dare-tasks

MCP Server Workflow

dare init my-mcp-server
# → Structure: MCP Server
# → Language: TypeScript
# → Transport: stdio
# → Capabilities: Tools, Resources

cd my-mcp-server
npm install
dare design "MCP server that exposes ZIP code lookup tools"
dare blueprint
dare execute --parallel

# Test with MCP Inspector
npm run inspect

Performance

| Mode | Estimated Time | |------|----------------| | Sequential | ~280 minutes | | Parallel DAG | ~70 minutes | | Improvement | 75% faster |

Supported Stacks

| Type | Options | |------|---------| | Backend | Rust/Axum · Node.js/NestJS · Python/FastAPI · PHP/Laravel · Go/Gin · Go/stdlib | | Frontend | React 18+ · Vue 3+ · Leptos fullstack (Rust SSR+WASM) · Leptos CSR (Rust WASM) | | MCP Server | TypeScript/Node.js · Python — stdio / SSE / HTTP Stream | | IDE / Agent | Claude Code · Cursor · Antigravity · Hybrid |

O que vem com o pacote (v2.0+)

A partir da v2.0 o @dewtech/dare-cli é um pacote único que inclui todas as funcionalidades do framework DARE. Você não precisa instalar nada além dele:

npm install -g @dewtech/dare-cli

Isso já dá:

| Componente | O que é | |------------|---------| | CLI dare | init, design, blueprint, execute, discover | | CLI dare-mcp-server | Servidor MCP local de contexto (~95% economia de tokens) | | Engine GraphRAG | Grafo de conhecimento com SQLite + FTS5 | | DAG Task Runner | Execução paralela de tasks com Kahn's algorithm | | Tipos e templates | Tudo embutido — sem dependências externas do @dewtech/* |

Histórico (v1.x): os pacotes @dewtech/dare-core, @dewtech/dare-graphrag e @dewtech/dare-mcp-server foram consolidados em @dewtech/dare-cli e estão deprecated no npm. Não há mais subpacotes para gerenciar.

Links

• GitHub
• DARE Methodology
• Dewtech