Updated New Service Generator feature to build and

deploy service and database with a single command same
as existing service. Added regression tests.

Author: krishgok

.gitignore

@@ -27,4 +27,7 @@ desktop.ini
 logs/
 
 # ===== Claude =====
-.claude/
+.claude/
+
+# ===== tmp =====
+tmp/

CLAUDE.md

@@ -6,7 +6,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 `LocalDevelopmentStack` is a Kotlin CLI tool that scaffolds a local development environment. It has two modes:
 
-1. **New service scaffold** — given a service type and database, generates a complete runnable service + `docker-compose.yml` from scratch.
+1. **New service scaffold** — given a service type and database, generates a complete runnable service from a template, plus `Dockerfile.dev` and `docker-compose.yml`. The whole stack (DB + service) comes up with one `docker-compose up --build`; hot-reload is enabled.
 2. **Existing service scaffold** (`--existing-dir`) — auto-detects the language in an existing directory, then generates `Dockerfile.dev` + `docker-compose.yml` so the full local stack (service + database) runs with `docker-compose up --build`. Hot-reload is enabled; source changes are picked up automatically without a rebuild.
 
 Both modes support optional database-migration scaffolding via `--migration <tool>`, which adds an opt-in one-shot `migrate:` service to the generated compose file plus an example migration in the appropriate format for the tool.
@@ -167,7 +167,7 @@ All database services are named `db:` in the compose file so connection URLs use
 
 | `--service`  | Implementation                   | Hot-reload tool                    |
 | ------------ | -------------------------------- | ---------------------------------- |
-| `springboot` | `SpringBootDockerfileGenerator`  | `./gradlew bootRun`                |
+| `springboot` | `SpringBootDockerfileGenerator`  | `gradle bootRun`                   |
 | `go`         | `GoDockerfileGenerator`          | `air` (cosmtrek/air)               |
 | `python`     | `PythonDockerfileGenerator`      | `uvicorn --reload`                 |
 | `node`       | `NodeDockerfileGenerator`        | `nodemon`                          |
@@ -238,13 +238,16 @@ Multiple distinct types → `DetectionException` with explicit `--service` overr
 
 ### Generated output structure
 
+Both modes produce a stack that comes up with a single `docker-compose up --build` — DB + service container with hot-reload via volume-mounted source. The only difference is whether the source is generated from a template (new) or pre-existing (existing-dir). New-scaffold mode passes a `ServiceComposeConfig` with `buildContext = "./service"` so the compose `build:` block points at the subdirectory; existing-dir keeps the default `buildContext = "."`.
+
 **New service scaffold:**
 ```
 <output>/
 ├── service/
-│   └── <language-specific source files>
-│       └── GET /health → {"status":"ok"}
-└── docker-compose.yml    # database only; service runs directly on host
+│   ├── <language-specific source files>
+│   │   └── GET /health → {"status":"ok"}
+│   └── Dockerfile.dev    # single-stage, hot-reload, no COPY . .
+└── docker-compose.yml    # database + your service container (volume-mounted source)
 ```
 
 **Existing service scaffold:**

README.md

@@ -2,9 +2,9 @@
 
 Instantly scaffold a containerised local development environment for any service and database — with a single command.
 
-Two modes:
+Two modes — both produce a stack that comes up with a single `docker-compose up --build`:
 
-- **New service** — generates a complete runnable service + `docker-compose.yml` from scratch.
+- **New service** — generates a complete runnable service + `Dockerfile.dev` + `docker-compose.yml` from scratch. Hot-reload enabled.
 - **Existing service** — wraps your existing code with a `Dockerfile.dev` + `docker-compose.yml`. Hot-reload is enabled; source changes are picked up automatically inside the container.
 
 Optional **database migrations** — pass `--migration <tool>` (Flyway, Liquibase, migrate-mongo, golang-migrate) to scaffold an example migration plus a one-shot `migrate:` service that runs on demand via `docker-compose run --rm migrate`.
@@ -45,35 +45,43 @@ irm https://raw.githubusercontent.com/krishgok/localdevstack/main/scripts/instal
 
 ## Usage: Scaffold a new service
 
-Generates source code + `docker-compose.yml` from scratch.
+Generates source code + `Dockerfile.dev` + `docker-compose.yml` from scratch. Hot-reload is enabled — edit source files and the watcher inside the container recompiles/restarts your service automatically.
 
 **Step 1 — Generate the stack:**
 
 ```bash
 localdevstack --service go --database postgres --output ./my-project --name my-api
 ```
 
-**Step 2 — Start the database:**
+This produces:
 
-```bash
-cd my-project
-docker-compose up -d
+```
+my-project/
+├── service/
+│   ├── <generated source files>
+│   └── Dockerfile.dev      ← dev container for your service (hot-reload enabled)
+└── docker-compose.yml      ← your service + the database, fully wired
 ```
 
-**Step 3 — Start the generated service:**
+**Step 2 — Start the full local stack:**
 
 ```bash
-cd service && go run ./...
+cd my-project
+docker-compose up --build
 ```
 
-**Step 4 — Verify:**
+This builds the dev image on first run and starts both the database and your service. Subsequent `docker-compose up` calls skip the build.
+
+**Step 3 — Verify:**
 
 ```bash
 curl http://localhost:8080/health
 # → {"status":"ok"}
 ```
 
-> The service runs directly on your host in this mode. Replace `go run ./...` with the appropriate command for your language (see [Supported service types](#supported-service-types)).
+**Step 4 — Edit, save, and see changes reload automatically:**
+
+Hot-reload works the same way as in [existing-service mode](#step-4--edit-save-and-see-changes-reload-automatically) — edit a source file under `service/`, the watcher inside the container picks it up. Only re-run `docker-compose up --build` if you change `Dockerfile.dev` itself or add/remove dependencies (e.g. `go.mod`, `package.json`, `requirements.txt`).
 
 ---
 
@@ -298,9 +306,8 @@ Pass `--migration <tool>` to scaffold migration files plus a one-shot `migrate:`
 ```bash
 localdevstack --service go --database postgres --migration flyway --output ./my-project --name my-api
 cd my-project
-docker-compose up -d                  # starts postgres only — migrate is skipped (compose profile)
-docker-compose run --rm migrate       # applies all pending migrations
-cd service && go run ./...            # start your service
+docker-compose up --build -d          # service + db (migrate skipped — compose profile)
+docker-compose run --rm migrate       # apply migrations on demand
 ```
 
 ### Existing service with migrations

my-test-stack/docker-compose.yml

@@ -0,0 +1,39 @@
+# WARNING: these credentials are for LOCAL DEVELOPMENT ONLY.
+# Change POSTGRES_PASSWORD before committing or deploying to any shared environment.
+
+services:
+  db:
+    image: postgres:16
+    container_name: local-postgres
+    environment:
+      POSTGRES_DB: app_db
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres_dev_only}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  my-test-api-service:
+    build:
+      context: ./service
+      dockerfile: Dockerfile.dev
+    container_name: local-my-test-api-service
+    ports:
+      - "8080:8080"
+    environment:
+      - DATABASE_URL=postgresql://postgres:postgres_dev_only@db:5432/app_db
+    volumes:
+      - ./service:/app
+      - /app/build
+      - /app/.gradle
+    depends_on:
+      db:
+        condition: service_healthy
+volumes:
+  postgres_data:

my-test-stack/service/Dockerfile.dev

@@ -0,0 +1,6 @@
+FROM gradle:8-jdk17-alpine
+WORKDIR /app
+COPY build.gradle.kts settings.gradle.kts ./
+RUN gradle dependencies --no-daemon -q 2>/dev/null || true
+EXPOSE 8080
+CMD ["gradle", "bootRun", "--no-daemon"]

my-test-stack/service/build.gradle.kts

@@ -0,0 +1,29 @@
+plugins {
+    kotlin("jvm") version "1.9.22"
+    kotlin("plugin.spring") version "1.9.22"
+    id("org.springframework.boot") version "3.2.3"
+    id("io.spring.dependency-management") version "1.1.4"
+}
+
+group = "com.example"
+version = "0.0.1-SNAPSHOT"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+    implementation("org.jetbrains.kotlin:kotlin-reflect")
+    runtimeOnly("org.postgresql:postgresql")
+    testImplementation("org.springframework.boot:spring-boot-starter-test")
+}
+
+kotlin {
+    jvmToolchain(17)
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+}

my-test-stack/service/go.mod

@@ -0,0 +1,3 @@
+module my-test-api-service
+
+go 1.22

my-test-stack/service/handler/health_handler.go

@@ -0,0 +1,19 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+type HealthHandler struct{}
+
+func NewHealthHandler() *HealthHandler {
+	return &HealthHandler{}
+}
+
+func (h *HealthHandler) Health(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(map[string]string{"status": "ok"}); err != nil {
+		http.Error(w, "encoding response", http.StatusInternalServerError)
+	}
+}

my-test-stack/service/main.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"log"
+	"net/http"
+
+	"my-test-api-service/handler"
+)
+
+func main() {
+	mux := http.NewServeMux()
+
+	healthHandler := handler.NewHealthHandler()
+	mux.HandleFunc("/health", healthHandler.Health)
+
+	log.Println("Server starting on :8080")
+	log.Fatal(http.ListenAndServe(":8080", mux))
+}

my-test-stack/service/service/health_service.go

@@ -0,0 +1,11 @@
+package service
+
+type HealthService struct{}
+
+func NewHealthService() *HealthService {
+	return &HealthService{}
+}
+
+func (s *HealthService) Status() string {
+	return "ok"
+}