@dewtech/dare-cli 2.17.0 → 3.1.0

package/templates/stacks/mcp-python/src/transports/http.py

@@ -0,0 +1,12 @@
+"""Streamable HTTP transport — modern MCP HTTP wire format.
+
+Each client gets its own session keyed by the Mcp-Session-Id header,
+generated on initialize. FastMCP wraps the uvicorn + Starlette plumbing.
+"""
+from mcp.server.fastmcp import FastMCP
+
+
+def run(mcp: FastMCP, host: str = "0.0.0.0", port: int = 3001) -> None:
+    mcp.settings.host = host
+    mcp.settings.port = port
+    mcp.run(transport="streamable-http")

package/templates/stacks/mcp-python/src/transports/sse.py

@@ -0,0 +1,13 @@
+"""SSE-over-HTTP transport — legacy MCP HTTP wire format.
+
+FastMCP launches a uvicorn server under the hood and exposes the SSE
+endpoints. For new deployments prefer the streamable HTTP transport
+(transports/http.py).
+"""
+from mcp.server.fastmcp import FastMCP
+
+
+def run(mcp: FastMCP, host: str = "0.0.0.0", port: int = 3001) -> None:
+    mcp.settings.host = host
+    mcp.settings.port = port
+    mcp.run(transport="sse")

package/templates/stacks/mcp-python/src/transports/stdio.py

@@ -0,0 +1,6 @@
+"""stdio transport — the default for local agents."""
+from mcp.server.fastmcp import FastMCP
+
+
+def run(mcp: FastMCP) -> None:
+    mcp.run(transport="stdio")

package/templates/stacks/mcp-python/tests/test_echo.py

@@ -0,0 +1,28 @@
+"""Smoke tests for echo tool and summarize prompt."""
+import pytest
+
+from src.prompts.summarize import summarize
+from src.tools.echo import echo
+
+
+@pytest.mark.asyncio
+async def test_echo_returns_input():
+    assert await echo("hello") == "hello"
+
+
+@pytest.mark.asyncio
+async def test_echo_rejects_empty():
+    with pytest.raises(ValueError):
+        await echo("")
+
+
+@pytest.mark.asyncio
+async def test_echo_rejects_non_string():
+    with pytest.raises(ValueError):
+        await echo(None)  # type: ignore[arg-type]
+
+
+def test_summarize_includes_input_text():
+    out = summarize("long text here")
+    assert "long text here" in out
+    assert "Summarize" in out

package/templates/stacks/mcp-rust/.dare/skills.yml

@@ -0,0 +1,8 @@
+version: 1
+skills:
+  - id: skill-mcp-server
+    source: skill-mcp-server
+    description: MCP server patterns (tools, prompts, transports)
+  - id: dare-ax
+    source: dare-ax
+    description: Agent eXperience invariants (llms.txt, OpenAPI, --json --list-tools, rate limit)

package/templates/stacks/mcp-rust/.env.example

@@ -0,0 +1,14 @@
+# MCP transport — overrides --transport flag if set
+# Valid: stdio | sse | http
+MCP_TRANSPORT=stdio
+
+# HTTP/SSE transport bind (ignored on stdio)
+MCP_HOST=0.0.0.0
+MCP_PORT=3001
+
+# Logging
+RUST_LOG=info
+
+# LLM provider (optional)
+LLM_PROVIDER=dummy
+# OPENAI_API_KEY=

package/templates/stacks/mcp-rust/.github/workflows/dare-ci.yml

@@ -0,0 +1,38 @@
+name: DARE CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  audit:
+    name: cargo audit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo install cargo-audit --locked
+      - run: cargo audit --deny warnings
+
+  lint:
+    name: clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy --all-targets -- -D warnings
+
+  test:
+    name: cargo test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo test

package/templates/stacks/mcp-rust/Cargo.toml.tera

@@ -0,0 +1,35 @@
+[package]
+name = "{{ crateName }}"
+version = "0.1.0"
+edition = "2021"
+description = "DARE-shaped MCP server (Rust)"
+license = "MIT"
+
+[dependencies]
+# Official Rust MCP SDK. API still stabilizing — pin a rev if upstream breaks.
+rmcp = { version = "0.1", features = ["server", "transport-io"] }
+
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+# HTTP/SSE transports
+axum = { version = "0.7", features = ["macros"] }
+tower-http = { version = "0.6", features = ["cors"] }
+
+# CLI args
+clap = { version = "4", features = ["derive", "env"] }
+
+# Logging
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+anyhow = "1"
+thiserror = "1"
+
+[dev-dependencies]
+tokio-test = "0.4"
+
+[[bin]]
+name = "{{ crateName }}"
+path = "src/main.rs"

package/templates/stacks/mcp-rust/README.md.tera

@@ -0,0 +1,50 @@
+# {{ projectName }}
+
+DARE-shaped MCP server in Rust using the `rmcp` SDK.
+Default transport: **{{ defaultTransport }}**.
+
+> ⚠️ **Beta.** The `rmcp` SDK API is still stabilizing. Pin a specific version
+> or git rev in `Cargo.toml` if an upstream release breaks the build.
+
+## Setup
+
+```bash
+cp .env.example .env
+cargo build
+cargo run                    # uses {{ defaultTransport }} transport by default
+```
+
+## Test with MCP Inspector
+
+```bash
+npx @modelcontextprotocol/inspector cargo run
+```
+
+## Tools
+
+- `echo` — returns its input. Canonical smoke test.
+
+## Prompts
+
+- `summarize` — placeholder prompt template taking a `text` argument.
+
+## Transports
+
+Pick at runtime via `--transport stdio|sse|http` or `MCP_TRANSPORT`:
+
+| Transport | When to use |
+|---|---|
+| `stdio` (default) | Local CLI agents |
+| `sse`             | Web clients via SSE (axum) |
+| `http`            | Streamable HTTP (axum) |
+
+## Commands
+
+- `cargo run` — start server
+- `cargo test` — tests
+- `cargo clippy -- -D warnings` — lint
+- `cargo audit` — dependency audit
+
+## DARE Method
+
+See `.dare/skills.yml` and `llms.txt`.

package/templates/stacks/mcp-rust/gitignore

@@ -0,0 +1,5 @@
+/target
+.env
+.env.local
+*.log
+.DS_Store

package/templates/stacks/mcp-rust/llms.txt.tera

@@ -0,0 +1,60 @@
+# {{ projectName }}
+
+DARE-shaped MCP server (Rust, rmcp SDK). Default transport: **{{ defaultTransport }}**. BETA.
+
+## Setup
+
+```bash
+cp .env.example .env
+cargo build
+cargo run
+```
+
+## Commands
+
+- `cargo run` — start server (transport via --transport or MCP_TRANSPORT env)
+- `cargo test` — tests
+- `cargo clippy -- -D warnings` — lint
+- `cargo audit` — RustSec advisory audit
+- `npx @modelcontextprotocol/inspector cargo run` — MCP Inspector
+
+## Tools (registered in src/server.rs)
+
+| Name | Input | Output | Description |
+|---|---|---|---|
+| `echo` | `text: String` | `String` | Returns input verbatim. Smoke test. |
+
+## Prompts
+
+| Name | Args | Description |
+|---|---|---|
+| `summarize` | `text` | Summarize the input text. Placeholder. |
+
+## Transports
+
+Choose with `--transport stdio|sse|http` or `MCP_TRANSPORT`:
+
+- `stdio` (default) — local agents. No port.
+- `sse` — SSE-over-HTTP on MCP_PORT (default 3001), served by axum.
+- `http` — Streamable HTTP on MCP_PORT, served by axum.
+
+## Architecture
+
+- `src/main.rs` — tokio entrypoint, parses args, dispatches transport.
+- `src/server.rs` — builds the rmcp service with tools + prompts.
+- `src/cli.rs` — clap arg parser + Transport enum + --list-tools.
+- `src/transports/{stdio,sse,http}.rs` — one runner per transport.
+- `src/tools/`, `src/prompts/` — pure functions, unit-tested.
+
+## CLI inventory
+
+`cargo run -- --json --list-tools` prints the tool registry as JSON (M-03).
+
+## Note on beta status
+
+`rmcp` is the official Rust MCP SDK but its API is pre-1.0. If a `cargo build`
+fails after a dependency update, pin `rmcp` to a known-good version in Cargo.toml.
+
+## DARE skills
+
+See `.dare/skills.yml`.

package/templates/stacks/mcp-rust/openapi.json.tera

@@ -0,0 +1,31 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "{{ projectName }}",
+    "version": "0.1.0",
+    "description": "MCP server JSON-RPC surface. MCP is not REST; this describes the HTTP/SSE transport envelopes only."
+  },
+  "paths": {
+    "/sse": {
+      "get": {
+        "summary": "SSE event stream",
+        "responses": { "200": { "description": "text/event-stream with MCP JSON-RPC frames" } }
+      }
+    },
+    "/messages": {
+      "post": {
+        "summary": "MCP JSON-RPC message (HTTP / SSE post-back)",
+        "requestBody": {
+          "required": true,
+          "content": { "application/json": { "schema": { "type": "object" } } }
+        },
+        "responses": {
+          "200": {
+            "description": "JSON-RPC 2.0 response",
+            "content": { "application/json": { "schema": { "type": "object" } } }
+          }
+        }
+      }
+    }
+  }
+}

package/templates/stacks/mcp-rust/src/cli.rs.tera

@@ -0,0 +1,33 @@
+//! CLI argument parsing — transport selection + tool inventory.
+use clap::{Parser, ValueEnum};
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub enum Transport {
+    Stdio,
+    Sse,
+    Http,
+}
+
+#[derive(Debug, Parser)]
+#[command(name = "{{ projectName }}", version, about = "DARE-shaped MCP server")]
+pub struct Cli {
+    /// Transport to serve on. Overridden by MCP_TRANSPORT env if that is set.
+    #[arg(long, value_enum, default_value = "{{ defaultTransport }}", env = "MCP_TRANSPORT")]
+    pub transport: Transport,
+
+    /// Bind host for sse/http transports.
+    #[arg(long, default_value = "0.0.0.0", env = "MCP_HOST")]
+    pub host: String,
+
+    /// Bind port for sse/http transports.
+    #[arg(long, default_value_t = 3001, env = "MCP_PORT")]
+    pub port: u16,
+
+    /// Emit machine-readable JSON (use with --list-tools).
+    #[arg(long)]
+    pub json: bool,
+
+    /// List registered tools as JSON and exit (M-03).
+    #[arg(long)]
+    pub list_tools: bool,
+}

package/templates/stacks/mcp-rust/src/lib.rs

@@ -0,0 +1,6 @@
+//! Public crate surface — re-exported for tests and the bin.
+pub mod cli;
+pub mod prompts;
+pub mod server;
+pub mod tools;
+pub mod transports;

package/templates/stacks/mcp-rust/src/main.rs.tera

@@ -0,0 +1,30 @@
+//! {{ projectName }} — MCP server entrypoint.
+use clap::Parser;
+use tracing_subscriber::EnvFilter;
+
+use {{ crateName }}::cli::{Cli, Transport};
+use {{ crateName }}::tools;
+use {{ crateName }}::transports;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let cli = Cli::parse();
+
+    // --json --list-tools short-circuits before starting any transport (M-03).
+    if cli.list_tools && cli.json {
+        let inventory = tools::inventory_json();
+        println!("{}", serde_json::to_string_pretty(&inventory)?);
+        return Ok(());
+    }
+
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .with_writer(std::io::stderr)
+        .init();
+
+    match cli.transport {
+        Transport::Stdio => transports::stdio::run().await,
+        Transport::Sse => transports::sse::run(&cli.host, cli.port).await,
+        Transport::Http => transports::http::run(&cli.host, cli.port).await,
+    }
+}

package/templates/stacks/mcp-rust/src/prompts/mod.rs

@@ -0,0 +1 @@
+pub mod summarize;

package/templates/stacks/mcp-rust/src/prompts/summarize.rs

@@ -0,0 +1,5 @@
+//! Summarize prompt — returns the templated user-message body.
+
+pub fn summarize(text: &str) -> String {
+    format!("Summarize the following text in 1-2 sentences.\n\n{text}")
+}

package/templates/stacks/mcp-rust/src/server.rs.tera

@@ -0,0 +1,38 @@
+//! MCP service definition — wires tools + prompts via the rmcp SDK.
+//!
+//! NOTE: the rmcp API is pre-1.0; the exact handler-registration surface may
+//! shift between releases. The structure below keeps the SDK glue thin and the
+//! business logic in `tools::` / `prompts::` (pure, unit-tested) so a breaking
+//! rmcp change only touches this file.
+use rmcp::{
+    handler::server::ServerHandler,
+    model::{ServerCapabilities, ServerInfo},
+};
+
+use crate::tools;
+
+#[derive(Clone, Default)]
+pub struct DareMcpService;
+
+impl ServerHandler for DareMcpService {
+    fn get_info(&self) -> ServerInfo {
+        ServerInfo {
+            instructions: Some(
+                "DARE-shaped MCP server ({{ projectName }}). Tools: echo. Prompts: summarize."
+                    .into(),
+            ),
+            capabilities: ServerCapabilities::builder()
+                .enable_tools()
+                .enable_prompts()
+                .build(),
+            ..Default::default()
+        }
+    }
+}
+
+/// Convenience constructor used by every transport.
+pub fn build_service() -> DareMcpService {
+    // Touch the tool inventory so a missing tool module is a compile error.
+    let _ = tools::inventory_json();
+    DareMcpService
+}

package/templates/stacks/mcp-rust/src/tools/echo.rs

@@ -0,0 +1,18 @@
+//! Echo tool — pure function, unit-tested independently of the SDK.
+
+/// Returns its input verbatim.
+///
+/// # Errors
+/// Returns `Err` when `text` is empty.
+pub fn echo(text: &str) -> Result<String, EchoError> {
+    if text.is_empty() {
+        return Err(EchoError::Empty);
+    }
+    Ok(text.to_string())
+}
+
+#[derive(Debug, thiserror::Error, PartialEq, Eq)]
+pub enum EchoError {
+    #[error("text must be a non-empty string")]
+    Empty,
+}

package/templates/stacks/mcp-rust/src/tools/mod.rs

@@ -0,0 +1,22 @@
+pub mod echo;
+
+use serde_json::{json, Value};
+
+/// Machine-readable tool inventory for `--json --list-tools` (M-03).
+pub fn inventory_json() -> Value {
+    json!({
+        "tools": [
+            {
+                "name": "echo",
+                "description": "Returns its input. Canonical smoke test for an MCP server.",
+                "inputSchema": {
+                    "type": "object",
+                    "required": ["text"],
+                    "properties": {
+                        "text": { "type": "string", "minLength": 1 }
+                    }
+                }
+            }
+        ]
+    })
+}

package/templates/stacks/mcp-rust/src/transports/http.rs

@@ -0,0 +1,27 @@
+//! Streamable HTTP transport.
+//!
+//! rmcp exposes a streamable-http server behind a feature flag in recent
+//! releases (pre-1.0). This wrapper centralizes the bind logic; swap the route
+//! bodies for rmcp's StreamableHttpService integration for your version.
+use std::net::SocketAddr;
+
+use crate::server::build_service;
+
+pub async fn run(host: &str, port: u16) -> anyhow::Result<()> {
+    let addr: SocketAddr = format!("{host}:{port}").parse()?;
+    tracing::info!("mcp/http listening on {addr}");
+
+    let _service = build_service();
+
+    let app = axum::Router::new()
+        .route(
+            "/messages",
+            axum::routing::post(|| async { "MCP streamable-http endpoint — wire rmcp here" })
+                .get(|| async { "MCP streamable-http endpoint — wire rmcp here" }),
+        )
+        .layer(tower_http::cors::CorsLayer::permissive());
+
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    axum::serve(listener, app).await?;
+    Ok(())
+}

package/templates/stacks/mcp-rust/src/transports/mod.rs

@@ -0,0 +1,3 @@
+pub mod http;
+pub mod sse;
+pub mod stdio;

package/templates/stacks/mcp-rust/src/transports/sse.rs

@@ -0,0 +1,33 @@
+//! SSE-over-HTTP transport.
+//!
+//! rmcp exposes an SSE server behind the `transport-sse-server` feature in
+//! recent releases; the surface is pre-1.0. This wrapper keeps the bind logic
+//! in one place. If the SDK feature name or constructor changes, only this
+//! file needs editing.
+use std::net::SocketAddr;
+
+use crate::server::build_service;
+
+pub async fn run(host: &str, port: u16) -> anyhow::Result<()> {
+    let addr: SocketAddr = format!("{host}:{port}").parse()?;
+    tracing::info!("mcp/sse listening on {addr}");
+
+    // Build the service so capabilities are validated even if the concrete
+    // SSE wiring below is adjusted for your rmcp version.
+    let _service = build_service();
+
+    // Minimal axum app that documents where the SSE endpoints live. Replace
+    // the route bodies with rmcp's SSE server integration for your version
+    // (e.g. rmcp::transport::sse_server::SseServer::serve(addr)).
+    let app = axum::Router::new()
+        .route("/sse", axum::routing::get(|| async { "MCP SSE endpoint — wire rmcp SseServer here" }))
+        .route(
+            "/messages",
+            axum::routing::post(|| async { "MCP message endpoint — wire rmcp SseServer here" }),
+        )
+        .layer(tower_http::cors::CorsLayer::permissive());
+
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    axum::serve(listener, app).await?;
+    Ok(())
+}

package/templates/stacks/mcp-rust/src/transports/stdio.rs

@@ -0,0 +1,14 @@
+//! stdio transport — default for local agents.
+//!
+//! Uses rmcp's stdio server. The exact serve call may differ across rmcp
+//! versions; adjust here if `cargo build` fails after an SDK bump.
+use rmcp::ServiceExt;
+
+use crate::server::build_service;
+
+pub async fn run() -> anyhow::Result<()> {
+    let service = build_service();
+    let server = service.serve((tokio::io::stdin(), tokio::io::stdout())).await?;
+    server.waiting().await?;
+    Ok(())
+}

package/templates/stacks/mcp-rust/tests/echo_test.rs.tera

@@ -0,0 +1,27 @@
+//! Smoke tests — pure tools/prompts, no SDK or transport needed.
+use {{ crateName }}::prompts::summarize::summarize;
+use {{ crateName }}::tools::echo::{echo, EchoError};
+
+#[test]
+fn echo_returns_input() {
+    assert_eq!(echo("hello").unwrap(), "hello");
+}
+
+#[test]
+fn echo_rejects_empty() {
+    assert_eq!(echo(""), Err(EchoError::Empty));
+}
+
+#[test]
+fn summarize_includes_input() {
+    let out = summarize("long text here");
+    assert!(out.contains("long text here"));
+    assert!(out.contains("Summarize"));
+}
+
+#[test]
+fn tool_inventory_lists_echo() {
+    let inv = {{ crateName }}::tools::inventory_json();
+    let tools = inv["tools"].as_array().expect("tools array");
+    assert!(tools.iter().any(|t| t["name"] == "echo"));
+}

package/templates/stacks/node-nestjs/.dare/skills.yml

@@ -0,0 +1,11 @@
+version: 1
+skills:
+  - id: skill-nestjs-api
+    source: skill-nestjs-api
+    description: NestJS Layered Design + Prisma + JWT + Swagger
+  - id: dare-ax
+    source: dare-ax
+    description: Agent eXperience invariants (llms.txt, OpenAPI, --json, rate limit)
+  - id: dare-layered-design
+    source: dare-layered-design
+    description: Handler → Service → Repository → Model 4-layer architecture

package/templates/stacks/node-nestjs/.env.example

@@ -0,0 +1,21 @@
+# Application
+PORT=3000
+LOG_LEVEL=info
+
+# Database
+DATABASE_URL=postgresql://user:pass@localhost:5432/myapi
+
+# JWT auth
+JWT_SECRET=replace-me-in-prod
+JWT_EXPIRES_IN=15m
+
+# Password hashing
+BCRYPT_COST=12
+
+# Throttler (rate limit)
+RATE_LIMIT_RPM=60
+RATE_LIMIT_TTL=60
+
+# LLM provider (optional)
+# LLM_PROVIDER=dummy
+# OPENAI_API_KEY=