@dewtech/dare-cli 2.17.0 → 3.1.0

package/dist/utils/stack-bootstrap.js

@@ -14,22 +14,32 @@ import { spawn } from 'node:child_process';
 import path from 'node:path';
 import fs from 'fs-extra';
 import chalk from 'chalk';
+const MCP_LANGUAGE_TO_STACK = {
+    'node-ts': 'mcp-node-ts',
+    python: 'mcp-python',
+    rust: 'mcp-rust',
+    go: 'mcp-go',
+};
 // ─── Public API ─────────────────────────────────────────────────────────────
 export async function bootstrapBackend(opts) {
     const mode = opts.toolchain ?? 'auto';
+    // v3.1: all backend stack ids match registry StackId 1:1, so route every
+    // one through the internalized scaffolder. The old official-tool bootstrap
+    // functions (bootstrapNodeNestjs/npx, bootstrapPhpLaravel/composer, …) are
+    // retained only as historical reference and no longer reached from init.
+    const BACKEND_IDS = new Set([
+        'ruby-rails-8',
+        'php-laravel',
+        'node-nestjs',
+        'python-fastapi',
+        'rust-axum',
+        'go-gin',
+        'go-stdlib',
+    ]);
+    if (BACKEND_IDS.has(opts.stack)) {
+        return bootstrapViaRegistry(opts.stack, opts.dir, opts.projectName, opts.isMonorepo ?? false, mode);
+    }
     switch (opts.stack) {
-        case 'php-laravel':
-            return bootstrapPhpLaravel(opts.dir, opts.projectName, mode);
-        case 'node-nestjs':
-            return bootstrapNodeNestjs(opts.dir, opts.projectName, mode);
-        case 'python-fastapi':
-            return bootstrapPythonFastapi(opts.dir, mode);
-        case 'rust-axum':
-            return bootstrapRustAxum(opts.dir, opts.projectName, mode, opts.isMonorepo ?? false);
-        case 'go-gin':
-            return bootstrapGoGin(opts.dir, opts.projectName, mode);
-        case 'go-stdlib':
-            return bootstrapGoStdlib(opts.dir, opts.projectName, mode);
         default:
             throw new Error(`Unknown backend stack: ${opts.stack}`);
     }
@@ -57,11 +67,11 @@ export async function bootstrapFrontend(opts) {
 }
 export async function bootstrapMcp(opts) {
     const mode = opts.toolchain ?? 'auto';
+    const stackId = MCP_LANGUAGE_TO_STACK[opts.language];
+    if (stackId) {
+        return bootstrapViaRegistry(stackId, opts.dir, opts.projectName, false, mode, opts.transport ?? 'stdio');
+    }
     switch (opts.language) {
-        case 'node-ts':
-            return bootstrapMcpNode(opts.dir, opts.projectName, mode);
-        case 'python':
-            return bootstrapMcpPython(opts.dir, mode);
         default:
             throw new Error(`Unknown MCP language: ${opts.language}`);
     }
@@ -323,73 +333,73 @@ async function bootstrapGoGin(dir, projectName, mode) {
     await fs.ensureDir(path.join(dir, 'cmd', 'api'));
     await fs.ensureDir(path.join(dir, 'internal', 'handlers'));
     await fs.ensureDir(path.join(dir, 'internal', 'middleware'));
-    await fs.writeFile(path.join(dir, 'cmd', 'api', 'main.go'), `package main
-
-import (
-\t"log"
-\t"os"
-
-\t"github.com/gin-gonic/gin"
-\t"${moduleName}/internal/handlers"
-)
-
-func main() {
-\tr := gin.Default()
-
-\tr.GET("/healthz", handlers.Health)
-
-\tv1 := r.Group("/api/v1")
-\t{
-\t\tv1.GET("/", func(c *gin.Context) {
-\t\t\tc.JSON(200, gin.H{"message": "API v1"})
-\t\t})
-\t}
-
-\tport := os.Getenv("PORT")
-\tif port == "" {
-\t\tport = "8080"
-\t}
-\tif err := r.Run(":" + port); err != nil {
-\t\tlog.Fatal(err)
-\t}
-}
+    await fs.writeFile(path.join(dir, 'cmd', 'api', 'main.go'), `package main
+
+import (
+\t"log"
+\t"os"
+
+\t"github.com/gin-gonic/gin"
+\t"${moduleName}/internal/handlers"
+)
+
+func main() {
+\tr := gin.Default()
+
+\tr.GET("/healthz", handlers.Health)
+
+\tv1 := r.Group("/api/v1")
+\t{
+\t\tv1.GET("/", func(c *gin.Context) {
+\t\t\tc.JSON(200, gin.H{"message": "API v1"})
+\t\t})
+\t}
+
+\tport := os.Getenv("PORT")
+\tif port == "" {
+\t\tport = "8080"
+\t}
+\tif err := r.Run(":" + port); err != nil {
+\t\tlog.Fatal(err)
+\t}
+}
 `);
-    await fs.writeFile(path.join(dir, 'internal', 'handlers', 'health.go'), `package handlers
-
-import (
-\t"net/http"
-
-\t"github.com/gin-gonic/gin"
-)
-
-// Health returns 200 with a small status payload.
-func Health(c *gin.Context) {
-\tc.JSON(http.StatusOK, gin.H{"status": "ok"})
-}
+    await fs.writeFile(path.join(dir, 'internal', 'handlers', 'health.go'), `package handlers
+
+import (
+\t"net/http"
+
+\t"github.com/gin-gonic/gin"
+)
+
+// Health returns 200 with a small status payload.
+func Health(c *gin.Context) {
+\tc.JSON(http.StatusOK, gin.H{"status": "ok"})
+}
 `);
-    await fs.writeFile(path.join(dir, 'internal', 'handlers', 'health_test.go'), `package handlers
-
-import (
-\t"net/http"
-\t"net/http/httptest"
-\t"testing"
-
-\t"github.com/gin-gonic/gin"
-)
-
-func TestHealth(t *testing.T) {
-\tgin.SetMode(gin.TestMode)
-\tr := gin.New()
-\tr.GET("/healthz", Health)
-
-\treq := httptest.NewRequest(http.MethodGet, "/healthz", nil)
-\trec := httptest.NewRecorder()
-\tr.ServeHTTP(rec, req)
-
-\tif rec.Code != http.StatusOK {
-\t\tt.Fatalf("expected 200, got %d", rec.Code)
-\t}
-}
+    await fs.writeFile(path.join(dir, 'internal', 'handlers', 'health_test.go'), `package handlers
+
+import (
+\t"net/http"
+\t"net/http/httptest"
+\t"testing"
+
+\t"github.com/gin-gonic/gin"
+)
+
+func TestHealth(t *testing.T) {
+\tgin.SetMode(gin.TestMode)
+\tr := gin.New()
+\tr.GET("/healthz", Health)
+
+\treq := httptest.NewRequest(http.MethodGet, "/healthz", nil)
+\trec := httptest.NewRecorder()
+\tr.ServeHTTP(rec, req)
+
+\tif rec.Code != http.StatusOK {
+\t\tt.Fatalf("expected 200, got %d", rec.Code)
+\t}
+}
 `);
     await go.run(['mod', 'tidy']);
 }
@@ -416,149 +426,149 @@ async function bootstrapGoStdlib(dir, projectName, mode) {
     await fs.ensureDir(path.join(dir, 'internal', 'middleware'));
     // cmd/api/main.go — http.NewServeMux with the Go 1.22+ pattern syntax,
     // wired through a logging + recover middleware chain.
-    await fs.writeFile(path.join(dir, 'cmd', 'api', 'main.go'), `package main
-
-import (
-\t"log"
-\t"log/slog"
-\t"net/http"
-\t"os"
-
-\t"${moduleName}/internal/handlers"
-\t"${moduleName}/internal/middleware"
-)
-
-func main() {
-\tlogger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
-\tslog.SetDefault(logger)
-
-\tmux := http.NewServeMux()
-
-\tmux.HandleFunc("GET /healthz", handlers.Health)
-
-\t// Example resource — replace with real routes per BLUEPRINT.md.
-\tmux.HandleFunc("GET /api/v1/", handlers.RootV1)
-
-\thandler := middleware.Recover(middleware.Logger(mux))
-
-\tport := os.Getenv("PORT")
-\tif port == "" {
-\t\tport = "8080"
-\t}
-\tslog.Info("server starting", "addr", ":"+port)
-\tif err := http.ListenAndServe(":"+port, handler); err != nil {
-\t\tlog.Fatal(err)
-\t}
-}
+    await fs.writeFile(path.join(dir, 'cmd', 'api', 'main.go'), `package main
+
+import (
+\t"log"
+\t"log/slog"
+\t"net/http"
+\t"os"
+
+\t"${moduleName}/internal/handlers"
+\t"${moduleName}/internal/middleware"
+)
+
+func main() {
+\tlogger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
+\tslog.SetDefault(logger)
+
+\tmux := http.NewServeMux()
+
+\tmux.HandleFunc("GET /healthz", handlers.Health)
+
+\t// Example resource — replace with real routes per BLUEPRINT.md.
+\tmux.HandleFunc("GET /api/v1/", handlers.RootV1)
+
+\thandler := middleware.Recover(middleware.Logger(mux))
+
+\tport := os.Getenv("PORT")
+\tif port == "" {
+\t\tport = "8080"
+\t}
+\tslog.Info("server starting", "addr", ":"+port)
+\tif err := http.ListenAndServe(":"+port, handler); err != nil {
+\t\tlog.Fatal(err)
+\t}
+}
 `);
     // internal/handlers/health.go
-    await fs.writeFile(path.join(dir, 'internal', 'handlers', 'health.go'), `package handlers
-
-import (
-\t"encoding/json"
-\t"net/http"
-)
-
-// Health returns 200 with a small JSON status payload.
-func Health(w http.ResponseWriter, r *http.Request) {
-\twriteJSON(w, http.StatusOK, map[string]string{"status": "ok"})
-}
-
-// RootV1 is a placeholder for the v1 root handler — replace per BLUEPRINT.
-func RootV1(w http.ResponseWriter, r *http.Request) {
-\twriteJSON(w, http.StatusOK, map[string]string{"message": "API v1"})
-}
-
-func writeJSON(w http.ResponseWriter, status int, body any) {
-\tw.Header().Set("Content-Type", "application/json")
-\tw.WriteHeader(status)
-\t_ = json.NewEncoder(w).Encode(body)
-}
+    await fs.writeFile(path.join(dir, 'internal', 'handlers', 'health.go'), `package handlers
+
+import (
+\t"encoding/json"
+\t"net/http"
+)
+
+// Health returns 200 with a small JSON status payload.
+func Health(w http.ResponseWriter, r *http.Request) {
+\twriteJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}
+
+// RootV1 is a placeholder for the v1 root handler — replace per BLUEPRINT.
+func RootV1(w http.ResponseWriter, r *http.Request) {
+\twriteJSON(w, http.StatusOK, map[string]string{"message": "API v1"})
+}
+
+func writeJSON(w http.ResponseWriter, status int, body any) {
+\tw.Header().Set("Content-Type", "application/json")
+\tw.WriteHeader(status)
+\t_ = json.NewEncoder(w).Encode(body)
+}
 `);
     // internal/handlers/health_test.go — uses net/http/httptest from stdlib.
-    await fs.writeFile(path.join(dir, 'internal', 'handlers', 'health_test.go'), `package handlers
-
-import (
-\t"encoding/json"
-\t"net/http"
-\t"net/http/httptest"
-\t"testing"
-)
-
-func TestHealth(t *testing.T) {
-\treq := httptest.NewRequest(http.MethodGet, "/healthz", nil)
-\trec := httptest.NewRecorder()
-
-\tHealth(rec, req)
-
-\tif rec.Code != http.StatusOK {
-\t\tt.Fatalf("expected 200, got %d", rec.Code)
-\t}
-
-\tvar body map[string]string
-\tif err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
-\t\tt.Fatalf("invalid JSON: %v", err)
-\t}
-\tif body["status"] != "ok" {
-\t\tt.Fatalf("expected status=ok, got %q", body["status"])
-\t}
-}
+    await fs.writeFile(path.join(dir, 'internal', 'handlers', 'health_test.go'), `package handlers
+
+import (
+\t"encoding/json"
+\t"net/http"
+\t"net/http/httptest"
+\t"testing"
+)
+
+func TestHealth(t *testing.T) {
+\treq := httptest.NewRequest(http.MethodGet, "/healthz", nil)
+\trec := httptest.NewRecorder()
+
+\tHealth(rec, req)
+
+\tif rec.Code != http.StatusOK {
+\t\tt.Fatalf("expected 200, got %d", rec.Code)
+\t}
+
+\tvar body map[string]string
+\tif err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+\t\tt.Fatalf("invalid JSON: %v", err)
+\t}
+\tif body["status"] != "ok" {
+\t\tt.Fatalf("expected status=ok, got %q", body["status"])
+\t}
+}
 `);
     // internal/middleware/logger.go
-    await fs.writeFile(path.join(dir, 'internal', 'middleware', 'logger.go'), `package middleware
-
-import (
-\t"log/slog"
-\t"net/http"
-\t"time"
-)
-
-// Logger emits a structured log line per request: method, path, status, duration.
-func Logger(next http.Handler) http.Handler {
-\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-\t\tstart := time.Now()
-\t\tsr := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
-\t\tnext.ServeHTTP(sr, r)
-\t\tslog.Info("http",
-\t\t\t"method", r.Method,
-\t\t\t"path", r.URL.Path,
-\t\t\t"status", sr.status,
-\t\t\t"duration_ms", time.Since(start).Milliseconds(),
-\t\t)
-\t})
-}
-
-type statusRecorder struct {
-\thttp.ResponseWriter
-\tstatus int
-}
-
-func (s *statusRecorder) WriteHeader(code int) {
-\ts.status = code
-\ts.ResponseWriter.WriteHeader(code)
-}
+    await fs.writeFile(path.join(dir, 'internal', 'middleware', 'logger.go'), `package middleware
+
+import (
+\t"log/slog"
+\t"net/http"
+\t"time"
+)
+
+// Logger emits a structured log line per request: method, path, status, duration.
+func Logger(next http.Handler) http.Handler {
+\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+\t\tstart := time.Now()
+\t\tsr := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
+\t\tnext.ServeHTTP(sr, r)
+\t\tslog.Info("http",
+\t\t\t"method", r.Method,
+\t\t\t"path", r.URL.Path,
+\t\t\t"status", sr.status,
+\t\t\t"duration_ms", time.Since(start).Milliseconds(),
+\t\t)
+\t})
+}
+
+type statusRecorder struct {
+\thttp.ResponseWriter
+\tstatus int
+}
+
+func (s *statusRecorder) WriteHeader(code int) {
+\ts.status = code
+\ts.ResponseWriter.WriteHeader(code)
+}
 `);
     // internal/middleware/recover.go
-    await fs.writeFile(path.join(dir, 'internal', 'middleware', 'recover.go'), `package middleware
-
-import (
-\t"log/slog"
-\t"net/http"
-)
-
-// Recover intercepts panics in handlers and turns them into 500 responses
-// instead of letting the goroutine crash the server.
-func Recover(next http.Handler) http.Handler {
-\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-\t\tdefer func() {
-\t\t\tif rec := recover(); rec != nil {
-\t\t\t\tslog.Error("panic recovered", "value", rec, "path", r.URL.Path)
-\t\t\t\thttp.Error(w, "internal server error", http.StatusInternalServerError)
-\t\t\t}
-\t\t}()
-\t\tnext.ServeHTTP(w, r)
-\t})
-}
+    await fs.writeFile(path.join(dir, 'internal', 'middleware', 'recover.go'), `package middleware
+
+import (
+\t"log/slog"
+\t"net/http"
+)
+
+// Recover intercepts panics in handlers and turns them into 500 responses
+// instead of letting the goroutine crash the server.
+func Recover(next http.Handler) http.Handler {
+\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+\t\tdefer func() {
+\t\t\tif rec := recover(); rec != nil {
+\t\t\t\tslog.Error("panic recovered", "value", rec, "path", r.URL.Path)
+\t\t\t\thttp.Error(w, "internal server error", http.StatusInternalServerError)
+\t\t\t}
+\t\t}()
+\t\tnext.ServeHTTP(w, r)
+\t})
+}
 `);
     await go.run(['mod', 'tidy']);
 }
@@ -643,126 +653,126 @@ async function bootstrapLeptosFullstack(dir, projectName, mode, isMonorepo) {
         ``,
     ].join('\n'));
     // src/lib.rs — shared App component + hydrate entry for WASM
-    await fs.writeFile(path.join(dir, 'src', 'lib.rs'), `pub mod app;
-
-#[cfg(feature = "hydrate")]
-#[wasm_bindgen::prelude::wasm_bindgen]
-pub fn hydrate() {
-    use app::App;
-    console_error_panic_hook::set_once();
-    leptos::mount::hydrate_body(App);
-}
+    await fs.writeFile(path.join(dir, 'src', 'lib.rs'), `pub mod app;
+
+#[cfg(feature = "hydrate")]
+#[wasm_bindgen::prelude::wasm_bindgen]
+pub fn hydrate() {
+    use app::App;
+    console_error_panic_hook::set_once();
+    leptos::mount::hydrate_body(App);
+}
 `);
     // src/app.rs — App component with basic router
-    await fs.writeFile(path.join(dir, 'src', 'app.rs'), `use leptos::prelude::*;
-use leptos_meta::*;
-use leptos_router::{components::Router, path};
-
-pub fn shell(options: LeptosOptions) -> impl IntoView {
-    view! {
-        <!DOCTYPE html>
-        <html lang="en">
-            <head>
-                <meta charset="UTF-8"/>
-                <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-                <AutoReload options=options.clone()/>
-                <HydrationScripts options=options.clone()/>
-                <MetaTags/>
-            </head>
-            <body>
-                <App/>
-            </body>
-        </html>
-    }
-}
-
-#[component]
-pub fn App() -> impl IntoView {
-    provide_meta_context();
-
-    view! {
-        <Title text="${projectName}"/>
-        <Router>
-            <main>
-                <Routes fallback=|| view! { <p>"Not found."</p> }>
-                    <Route path=path!("/") view=HomePage/>
-                </Routes>
-            </main>
-        </Router>
-    }
-}
-
-#[component]
-fn HomePage() -> impl IntoView {
-    let (count, set_count) = signal(0);
-
-    view! {
-        <h1>"${projectName}"</h1>
-        <button on:click=move |_| set_count.update(|n| *n += 1)>
-            "Count: " {count}
-        </button>
-    }
-}
+    await fs.writeFile(path.join(dir, 'src', 'app.rs'), `use leptos::prelude::*;
+use leptos_meta::*;
+use leptos_router::{components::Router, path};
+
+pub fn shell(options: LeptosOptions) -> impl IntoView {
+    view! {
+        <!DOCTYPE html>
+        <html lang="en">
+            <head>
+                <meta charset="UTF-8"/>
+                <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+                <AutoReload options=options.clone()/>
+                <HydrationScripts options=options.clone()/>
+                <MetaTags/>
+            </head>
+            <body>
+                <App/>
+            </body>
+        </html>
+    }
+}
+
+#[component]
+pub fn App() -> impl IntoView {
+    provide_meta_context();
+
+    view! {
+        <Title text="${projectName}"/>
+        <Router>
+            <main>
+                <Routes fallback=|| view! { <p>"Not found."</p> }>
+                    <Route path=path!("/") view=HomePage/>
+                </Routes>
+            </main>
+        </Router>
+    }
+}
+
+#[component]
+fn HomePage() -> impl IntoView {
+    let (count, set_count) = signal(0);
+
+    view! {
+        <h1>"${projectName}"</h1>
+        <button on:click=move |_| set_count.update(|n| *n += 1)>
+            "Count: " {count}
+        </button>
+    }
+}
 `.replace(/\${projectName}/g, projectName));
     // src/main.rs — SSR server entry (Axum + leptos_axum)
-    await fs.writeFile(path.join(dir, 'src', 'main.rs'), `#[cfg(feature = "ssr")]
-#[tokio::main]
-async fn main() {
-    use axum::Router;
-    use leptos::prelude::*;
-    use leptos_axum::{generate_route_list, LeptosRoutes};
-    use ${crateIdent}::app::{shell, App};
-
-    let conf = get_configuration(None).unwrap();
-    let leptos_options = conf.leptos_options;
-    let addr = leptos_options.site_addr;
-    let routes = generate_route_list(App);
-
-    let app = Router::new()
-        .leptos_routes(&leptos_options, routes, {
-            let leptos_options = leptos_options.clone();
-            move || shell(leptos_options.clone())
-        })
-        .fallback(leptos_axum::file_and_error_handler(shell))
-        .with_state(leptos_options);
-
-    println!("Listening on http://{}", addr);
-    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
-    axum::serve(listener, app).await.unwrap();
-}
-
-#[cfg(not(feature = "ssr"))]
-pub fn main() {}
+    await fs.writeFile(path.join(dir, 'src', 'main.rs'), `#[cfg(feature = "ssr")]
+#[tokio::main]
+async fn main() {
+    use axum::Router;
+    use leptos::prelude::*;
+    use leptos_axum::{generate_route_list, LeptosRoutes};
+    use ${crateIdent}::app::{shell, App};
+
+    let conf = get_configuration(None).unwrap();
+    let leptos_options = conf.leptos_options;
+    let addr = leptos_options.site_addr;
+    let routes = generate_route_list(App);
+
+    let app = Router::new()
+        .leptos_routes(&leptos_options, routes, {
+            let leptos_options = leptos_options.clone();
+            move || shell(leptos_options.clone())
+        })
+        .fallback(leptos_axum::file_and_error_handler(shell))
+        .with_state(leptos_options);
+
+    println!("Listening on http://{}", addr);
+    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
+
+#[cfg(not(feature = "ssr"))]
+pub fn main() {}
 `);
     // style/main.scss
-    await fs.writeFile(path.join(dir, 'style', 'main.scss'), `:root {
-  font-family: system-ui, sans-serif;
-}
-
-body {
-  max-width: 800px;
-  margin: 0 auto;
-  padding: 2rem;
-}
-
-h1 {
-  color: #b7410e;
-}
-
-button {
-  padding: 0.5rem 1rem;
-  font-size: 1rem;
-  cursor: pointer;
-}
+    await fs.writeFile(path.join(dir, 'style', 'main.scss'), `:root {
+  font-family: system-ui, sans-serif;
+}
+
+body {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+
+h1 {
+  color: #b7410e;
+}
+
+button {
+  padding: 0.5rem 1rem;
+  font-size: 1rem;
+  cursor: pointer;
+}
 `);
     // .cargo/config.toml — only needed when this crate is the workspace root.
     // In a monorepo the root Cargo workspace already has this file; writing it
     // inside the frontend/ member dir is redundant and can confuse tooling.
     if (!isMonorepo) {
-        await fs.writeFile(path.join(dir, '.cargo', 'config.toml'), `# DARE: Do NOT add a global [build] target here.
-# Mixed workspaces (Leptos WASM + native crates like napi-rs or aya) will break
-# if cargo tries to compile all crates for the same target.
-# cargo-leptos manages wasm32-unknown-unknown target per-crate automatically.
+        await fs.writeFile(path.join(dir, '.cargo', 'config.toml'), `# DARE: Do NOT add a global [build] target here.
+# Mixed workspaces (Leptos WASM + native crates like napi-rs or aya) will break
+# if cargo tries to compile all crates for the same target.
+# cargo-leptos manages wasm32-unknown-unknown target per-crate automatically.
 `);
     }
     await cargo.run(['fetch']);
@@ -811,77 +821,77 @@ async function bootstrapLeptosCsr(dir, projectName, mode, isMonorepo) {
         ``,
     ].join('\n'));
     // src/lib.rs — App component, mount entry for trunk
-    await fs.writeFile(path.join(dir, 'src', 'lib.rs'), `use leptos::prelude::*;
-
-pub fn main() {
-    console_error_panic_hook::set_once();
-    leptos::mount::mount_to_body(App);
-}
-
-#[component]
-pub fn App() -> impl IntoView {
-    let (count, set_count) = signal(0);
-
-    view! {
-        <main>
-            <h1>"${projectName}"</h1>
-            <button on:click=move |_| set_count.update(|n| *n += 1)>
-                "Count: " {count}
-            </button>
-        </main>
-    }
-}
+    await fs.writeFile(path.join(dir, 'src', 'lib.rs'), `use leptos::prelude::*;
+
+pub fn main() {
+    console_error_panic_hook::set_once();
+    leptos::mount::mount_to_body(App);
+}
+
+#[component]
+pub fn App() -> impl IntoView {
+    let (count, set_count) = signal(0);
+
+    view! {
+        <main>
+            <h1>"${projectName}"</h1>
+            <button on:click=move |_| set_count.update(|n| *n += 1)>
+                "Count: " {count}
+            </button>
+        </main>
+    }
+}
 `.replace('${projectName}', projectName));
     // index.html — trunk entry point (data-trunk attributes tell trunk what to bundle)
-    await fs.writeFile(path.join(dir, 'index.html'), `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${projectName}</title>
-    <link data-trunk rel="scss" href="style/main.scss" />
-    <link data-trunk rel="rust" href="Cargo.toml" data-wasm-opt="z" />
-  </head>
-  <body></body>
-</html>
+    await fs.writeFile(path.join(dir, 'index.html'), `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${projectName}</title>
+    <link data-trunk rel="scss" href="style/main.scss" />
+    <link data-trunk rel="rust" href="Cargo.toml" data-wasm-opt="z" />
+  </head>
+  <body></body>
+</html>
 `.replace(/\${projectName}/g, projectName));
     // Trunk.toml
-    await fs.writeFile(path.join(dir, 'Trunk.toml'), `[build]
-target = "index.html"
-dist = "dist"
-
-[watch]
-ignore = ["./dist"]
-
-[serve]
-port = 3001
-open = false
+    await fs.writeFile(path.join(dir, 'Trunk.toml'), `[build]
+target = "index.html"
+dist = "dist"
+
+[watch]
+ignore = ["./dist"]
+
+[serve]
+port = 3001
+open = false
 `);
     // style/main.scss
-    await fs.writeFile(path.join(dir, 'style', 'main.scss'), `:root {
-  font-family: system-ui, sans-serif;
-}
-
-body {
-  max-width: 800px;
-  margin: 0 auto;
-  padding: 2rem;
-}
-
-h1 {
-  color: #b7410e;
-}
-
-button {
-  padding: 0.5rem 1rem;
-  font-size: 1rem;
-  cursor: pointer;
-}
+    await fs.writeFile(path.join(dir, 'style', 'main.scss'), `:root {
+  font-family: system-ui, sans-serif;
+}
+
+body {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+
+h1 {
+  color: #b7410e;
+}
+
+button {
+  padding: 0.5rem 1rem;
+  font-size: 1rem;
+  cursor: pointer;
+}
 `);
     // .cargo/config.toml — omit when inside a Cargo workspace (root already has it)
     if (!isMonorepo) {
-        await fs.writeFile(path.join(dir, '.cargo', 'config.toml'), `# DARE: Do NOT add a global [build] target here.
-# trunk manages wasm32-unknown-unknown target automatically via its own build pipeline.
+        await fs.writeFile(path.join(dir, '.cargo', 'config.toml'), `# DARE: Do NOT add a global [build] target here.
+# trunk manages wasm32-unknown-unknown target automatically via its own build pipeline.
 `);
     }
     await cargo.run(['fetch']);
@@ -955,6 +965,26 @@ async function bootstrapMcpPython(dir, mode) {
     await python.runOther(venvPython, ['-m', 'pip', 'install', '--upgrade', 'pip']);
     await python.runOther(venvPython, ['-m', 'pip', 'install', 'mcp[cli]', 'pytest', 'ruff']);
 }
+/**
+ * v3.1 — Generic registry-backed bootstrap. Every stack (backend + MCP) lays
+ * down its DARE-shaped templates directly via its internalized scaffolder; no
+ * shell-out to the framework's official CLI. The user runs install/migrate
+ * steps afterwards (printed as postInstallSteps).
+ */
+async function bootstrapViaRegistry(stackId, dir, projectName, isMonorepo, mode, mcpTransport) {
+    banner(`Scaffolding ${stackId} (DARE-shaped) in ${dir}`);
+    const { resolve } = await import('../stacks/registry.js');
+    const { DARE_DNA } = await import('../stacks/types.js');
+    const scaffold = await resolve(stackId);
+    await scaffold.generate({
+        dir,
+        projectName,
+        toolchain: mode,
+        features: new Set(DARE_DNA),
+        isMonorepo,
+        mcp: scaffold.category === 'mcp' ? { transport: mcpTransport ?? 'stdio' } : undefined,
+    });
+}
 // ─── Helpers ────────────────────────────────────────────────────────────────
 function banner(msg) {
     console.log(chalk.blue.bold(`\n📦 ${msg}\n`));