biucingcli 0.9.1__py3-none-any.whl

biucingcli/template_data/web-service/template/internal/runtime/server_test.go

@@ -0,0 +1,139 @@
+package runtime
+
+import (
+	"context"
+	"errors"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"{{MODULE_NAME}}/internal/config"
+)
+
+func TestCheckHealthRequiresSuccessfulResponse(t *testing.T) {
+	healthServer := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		if request.URL.Path != "/healthz" {
+			writer.WriteHeader(http.StatusNotFound)
+			return
+		}
+		writer.WriteHeader(http.StatusOK)
+	}))
+	defer healthServer.Close()
+
+	if err := CheckHealth(context.Background(), healthServer.URL+"/healthz"); err != nil {
+		t.Fatal(err)
+	}
+	if err := CheckHealth(context.Background(), healthServer.URL+"/missing"); err == nil {
+		t.Fatal("expected a non-success status to fail the health check")
+	}
+}
+
+func TestNewHTTPServerAppliesTimeouts(t *testing.T) {
+	server := NewHTTPServer(config.Config{
+		Service: config.ServiceConfig{Port: "8080"},
+		Server: config.ServerConfig{
+			ReadTimeoutSeconds:       1,
+			ReadHeaderTimeoutSeconds: 2,
+			WriteTimeoutSeconds:      3,
+			IdleTimeoutSeconds:       4,
+		},
+	}, http.NewServeMux())
+
+	if server.ReadTimeout != time.Second || server.ReadHeaderTimeout != 2*time.Second {
+		t.Fatalf("unexpected read timeouts: %s, %s", server.ReadTimeout, server.ReadHeaderTimeout)
+	}
+	if server.WriteTimeout != 3*time.Second || server.IdleTimeout != 4*time.Second {
+		t.Fatalf("unexpected connection timeouts: %s, %s", server.WriteTimeout, server.IdleTimeout)
+	}
+}
+
+func TestServeDrainsInFlightRequest(t *testing.T) {
+	requestStarted := make(chan struct{})
+	releaseRequest := make(chan struct{})
+	handler := http.HandlerFunc(func(writer http.ResponseWriter, _ *http.Request) {
+		close(requestStarted)
+		<-releaseRequest
+		writer.WriteHeader(http.StatusNoContent)
+	})
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	serveDone := make(chan error, 1)
+	go func() {
+		serveDone <- Serve(ctx, &http.Server{Handler: handler}, listener, time.Second)
+	}()
+
+	requestDone := make(chan error, 1)
+	go func() {
+		response, requestErr := http.Get("http://" + listener.Addr().String())
+		if response != nil {
+			_ = response.Body.Close()
+		}
+		requestDone <- requestErr
+	}()
+
+	select {
+	case <-requestStarted:
+	case <-time.After(time.Second):
+		t.Fatal("request did not reach the server")
+	}
+
+	cancel()
+	select {
+	case err := <-serveDone:
+		t.Fatalf("server returned before the request drained: %v", err)
+	case <-time.After(25 * time.Millisecond):
+	}
+
+	close(releaseRequest)
+	if err := <-requestDone; err != nil {
+		t.Fatal(err)
+	}
+	if err := <-serveDone; err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestServeEnforcesShutdownTimeout(t *testing.T) {
+	requestStarted := make(chan struct{})
+	handler := http.HandlerFunc(func(_ http.ResponseWriter, request *http.Request) {
+		close(requestStarted)
+		<-request.Context().Done()
+	})
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	serveDone := make(chan error, 1)
+	go func() {
+		serveDone <- Serve(ctx, &http.Server{Handler: handler}, listener, 25*time.Millisecond)
+	}()
+	go func() {
+		_, _ = http.Get("http://" + listener.Addr().String())
+	}()
+
+	select {
+	case <-requestStarted:
+	case <-time.After(time.Second):
+		t.Fatal("request did not reach the server")
+	}
+	cancel()
+
+	select {
+	case err := <-serveDone:
+		if !errors.Is(err, context.DeadlineExceeded) {
+			t.Fatalf("expected shutdown deadline, got %v", err)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("shutdown timeout was not enforced")
+	}
+}

biucingcli/template_data/web-service/template/internal/service/health.go

@@ -0,0 +1,22 @@
+package service
+
+import "{{MODULE_NAME}}/internal/model"
+
+type HealthService interface {
+	Status() model.HealthResponse
+}
+
+type healthService struct {
+	serviceName string
+}
+
+func NewHealthService(serviceName string) HealthService {
+	return healthService{serviceName: serviceName}
+}
+
+func (service healthService) Status() model.HealthResponse {
+	return model.HealthResponse{
+		Service: service.serviceName,
+		Status:  "ok",
+	}
+}

biucingcli/template_data/web-service/template/internal/service/ping.go

@@ -0,0 +1,23 @@
+package service
+
+import "{{MODULE_NAME}}/internal/model"
+
+type PingService interface {
+	Ping() model.PingResponse
+}
+
+type pingService struct {
+	serviceName string
+}
+
+func NewPingService(serviceName string) PingService {
+	return pingService{serviceName: serviceName}
+}
+
+func (service pingService) Ping() model.PingResponse {
+	return model.PingResponse{
+		Service: service.serviceName,
+		Message: "pong",
+		Version: "v1",
+	}
+}

biucingcli/template_data/web-service/template/internal/service/user.go

@@ -0,0 +1,27 @@
+package service
+
+import (
+	"{{MODULE_NAME}}/internal/model"
+	"{{MODULE_NAME}}/internal/repository"
+)
+
+type UserService interface {
+	ListUsers() []model.User
+	GetUser(id string) (model.User, bool)
+}
+
+type userService struct {
+	repository repository.UserRepository
+}
+
+func NewUserService(repository repository.UserRepository) UserService {
+	return userService{repository: repository}
+}
+
+func (service userService) ListUsers() []model.User {
+	return service.repository.List()
+}
+
+func (service userService) GetUser(id string) (model.User, bool) {
+	return service.repository.GetByID(id)
+}

biucingcli/template_data/web-service/template/scripts/bootstrap

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if command -v brew >/dev/null 2>&1; then
+  brew bundle
+else
+  echo "brew not found; skipping Brewfile install."
+fi
+
+if command -v mise >/dev/null 2>&1; then
+  mise install
+else
+  echo "mise not found; skipping runtime install."
+fi
+
+if ! command -v go >/dev/null 2>&1; then
+  echo "go is not available on PATH."
+  echo "Install Go with Homebrew or activate it through mise, then rerun ./scripts/bootstrap."
+  exit 1
+fi
+
+go mod tidy
+./scripts/doctor

biucingcli/template_data/web-service/template/scripts/doctor

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if ! command -v go >/dev/null 2>&1; then
+  echo "go is not installed or not on PATH."
+  exit 1
+fi
+
+go_version="$(go env GOVERSION)"
+echo "Go toolchain: $go_version"
+
+if [[ -z "${GOCACHE:-}" ]]; then
+  export GOCACHE="$(pwd)/.cache/go-build"
+fi
+mkdir -p "$GOCACHE"
+
+if [[ ! -f "./go.mod" ]]; then
+  echo "go.mod is missing."
+  exit 1
+fi
+
+if [[ ! -f "./go.sum" ]]; then
+  echo "go.sum is missing."
+  echo "Run 'go mod tidy' or './scripts/bootstrap' to resolve dependencies first."
+  exit 1
+fi
+
+if [[ ! -f "./configs/config.yaml" ]]; then
+  echo "configs/config.yaml is missing."
+  exit 1
+fi
+
+if ! grep -q "name:" ./configs/config.yaml; then
+  echo "configs/config.yaml must define service.name."
+  exit 1
+fi
+
+if ! grep -q "port:" ./configs/config.yaml; then
+  echo "configs/config.yaml must define service.port."
+  exit 1
+fi
+
+service_name="$(sed -n 's/^  name: //p' ./configs/config.yaml | head -n 1)"
+service_port="$(sed -n 's/^  port: //p' ./configs/config.yaml | head -n 1)"
+
+if [[ -z "$service_name" ]]; then
+  echo "configs/config.yaml service.name must not be empty."
+  exit 1
+fi
+
+if [[ ! "$service_port" =~ ^[0-9]+$ ]]; then
+  echo "configs/config.yaml service.port must be a numeric string."
+  exit 1
+fi
+
+if (( service_port < 1 || service_port > 65535 )); then
+  echo "configs/config.yaml service.port must be between 1 and 65535."
+  exit 1
+fi
+
+if ! go list -m >/dev/null 2>&1; then
+  echo "go.mod does not define a valid module."
+  exit 1
+fi
+
+if ! CONFIG_FILE=./configs/config.yaml go test ./internal/config -run TestLoadDefaultConfig -count=1 >/dev/null; then
+  echo "config loader could not read configs/config.yaml successfully."
+  exit 1
+fi
+
+if command -v golangci-lint >/dev/null 2>&1; then
+  echo "golangci-lint: available"
+else
+  echo "golangci-lint: not installed; make lint and make verify will be unavailable."
+fi
+
+if command -v docker >/dev/null 2>&1; then
+  echo "Docker: available"
+else
+  echo "Docker: not installed; container workflows will be unavailable."
+fi
+
+echo "Environment looks ready."

biucingcli/template_data/web-service/template/tests/server_test.go

@@ -0,0 +1,160 @@
+package tests
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"{{MODULE_NAME}}/internal/config"
+	"{{MODULE_NAME}}/internal/model"
+	"{{MODULE_NAME}}/internal/router"
+)
+
+func TestHealthz(t *testing.T) {
+	engine := router.New(config.Config{
+		Service: config.ServiceConfig{
+			Name: "{{SERVICE_NAME}}",
+			Port: "{{HTTP_PORT}}",
+		},
+	})
+
+	request := httptest.NewRequest(http.MethodGet, "/healthz", nil)
+	recorder := httptest.NewRecorder()
+
+	engine.ServeHTTP(recorder, request)
+
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("expected status %d, got %d", http.StatusOK, recorder.Code)
+	}
+
+	var response model.HealthResponse
+	if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+		t.Fatal(err)
+	}
+
+	if response.Service != "{{SERVICE_NAME}}" {
+		t.Fatalf("expected service %q, got %q", "{{SERVICE_NAME}}", response.Service)
+	}
+
+	if response.Status != "ok" {
+		t.Fatalf("expected status %q, got %q", "ok", response.Status)
+	}
+}
+
+func TestListUsers(t *testing.T) {
+	engine := router.New(config.Config{
+		Service: config.ServiceConfig{
+			Name: "{{SERVICE_NAME}}",
+			Port: "{{HTTP_PORT}}",
+		},
+	})
+
+	request := httptest.NewRequest(http.MethodGet, "/api/v1/users", nil)
+	recorder := httptest.NewRecorder()
+
+	engine.ServeHTTP(recorder, request)
+
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("expected status %d, got %d", http.StatusOK, recorder.Code)
+	}
+
+	var response struct {
+		Items []model.User `json:"items"`
+	}
+	if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(response.Items) != 2 {
+		t.Fatalf("expected %d users, got %d", 2, len(response.Items))
+	}
+
+	if response.Items[0].ID != "u_001" {
+		t.Fatalf("expected first user id %q, got %q", "u_001", response.Items[0].ID)
+	}
+}
+
+func TestGetUser(t *testing.T) {
+	engine := router.New(config.Config{
+		Service: config.ServiceConfig{
+			Name: "{{SERVICE_NAME}}",
+			Port: "{{HTTP_PORT}}",
+		},
+	})
+
+	request := httptest.NewRequest(http.MethodGet, "/api/v1/users/u_002", nil)
+	recorder := httptest.NewRecorder()
+
+	engine.ServeHTTP(recorder, request)
+
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("expected status %d, got %d", http.StatusOK, recorder.Code)
+	}
+
+	var response model.User
+	if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+		t.Fatal(err)
+	}
+
+	if response.ID != "u_002" {
+		t.Fatalf("expected user id %q, got %q", "u_002", response.ID)
+	}
+
+	if response.Email != "alan@example.com" {
+		t.Fatalf("expected email %q, got %q", "alan@example.com", response.Email)
+	}
+}
+
+func TestGetUserNotFound(t *testing.T) {
+	engine := router.New(config.Config{
+		Service: config.ServiceConfig{
+			Name: "{{SERVICE_NAME}}",
+			Port: "{{HTTP_PORT}}",
+		},
+	})
+
+	request := httptest.NewRequest(http.MethodGet, "/api/v1/users/u_999", nil)
+	recorder := httptest.NewRecorder()
+
+	engine.ServeHTTP(recorder, request)
+
+	if recorder.Code != http.StatusNotFound {
+		t.Fatalf("expected status %d, got %d", http.StatusNotFound, recorder.Code)
+	}
+}
+
+func TestPing(t *testing.T) {
+	engine := router.New(config.Config{
+		Service: config.ServiceConfig{
+			Name: "{{SERVICE_NAME}}",
+			Port: "{{HTTP_PORT}}",
+		},
+	})
+
+	request := httptest.NewRequest(http.MethodGet, "/api/v1/ping", nil)
+	recorder := httptest.NewRecorder()
+
+	engine.ServeHTTP(recorder, request)
+
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("expected status %d, got %d", http.StatusOK, recorder.Code)
+	}
+
+	var response model.PingResponse
+	if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+		t.Fatal(err)
+	}
+
+	if response.Service != "{{SERVICE_NAME}}" {
+		t.Fatalf("expected service %q, got %q", "{{SERVICE_NAME}}", response.Service)
+	}
+
+	if response.Message != "pong" {
+		t.Fatalf("expected message %q, got %q", "pong", response.Message)
+	}
+
+	if response.Version != "v1" {
+		t.Fatalf("expected version %q, got %q", "v1", response.Version)
+	}
+}

biucingcli/template_data/web-service/template.json

@@ -0,0 +1,88 @@
+{
+  "name": "web-service",
+  "description": "Go + Gin web service starter",
+  "category": "backend",
+  "stack": ["Go", "Gin"],
+  "tags": ["api", "docker", "go", "service"],
+  "platforms": ["linux", "container"],
+  "maturity": {
+    "level": "validated",
+    "summary": "Dockerized web service starter with bounded HTTP timeouts, graceful shutdown, runtime health checks, lint, and tests."
+  },
+  "validation": {
+    "status": "real-build-verified",
+    "verification_tier": "real-build",
+    "evidence": [
+      "python unittest template rendering coverage",
+      "generated-project graceful shutdown and timeout tests",
+      "runtime image HTTP health check",
+      "real docker runtime image builds",
+      "real docker development image builds"
+    ]
+  },
+  "operating_assumptions": [
+    "The starter is optimized for Go service development with Docker-based dev and runtime flows.",
+    "Generated projects are expected to keep config, build, and verification workflows repo-local."
+  ],
+  "workflow_labels": ["bootstrap", "dev", "verify", "build", "runtime"],
+  "commands": {
+    "bootstrap": "make bootstrap",
+    "doctor": "make doctor",
+    "lint": "make lint",
+    "test": "make test",
+    "verify": "make verify",
+    "build": "make build",
+    "clean": "make clean",
+    "help": "make help"
+  },
+  "worktree": {
+    "support_level": "worktree-ready",
+    "isolation_dimensions": [
+      "runtime-names",
+      "ports",
+      "caches",
+      "generated-output",
+      "cleanup",
+      "diagnostics"
+    ],
+    "diagnostics": [
+      "make worktree-info",
+      "make worktree-doctor"
+    ],
+    "cleanup": [
+      "make clean-worktree"
+    ]
+  },
+  "variables": [
+    {
+      "name": "project_name",
+      "required": true,
+      "validator": "project-name"
+    },
+    {
+      "name": "module_name",
+      "required": true,
+      "prompt": "Go module name: ",
+      "validator": "go-module"
+    },
+    {
+      "name": "service_name",
+      "required": false,
+      "default_from": "project_name",
+      "validator": "slug"
+    },
+    {
+      "name": "http_port",
+      "required": false,
+      "default": "8080",
+      "validator": "port"
+    }
+  ],
+  "next_steps": [
+    "make bootstrap",
+    "make dev",
+    "make verify",
+    "make docker-build",
+    "make docker-run"
+  ]
+}

biucingcli/template_data/worker/template/.dockerignore

@@ -0,0 +1,3 @@
+.git
+.cache
+bin

biucingcli/template_data/worker/template/.gitignore

@@ -0,0 +1,2 @@
+.cache/
+bin/

biucingcli/template_data/worker/template/.mise.toml

@@ -0,0 +1,2 @@
+[tools]
+go = "1.26.0"

biucingcli/template_data/worker/template/Brewfile

@@ -0,0 +1 @@
+brew "go"

biucingcli/template_data/worker/template/Dockerfile

@@ -0,0 +1,19 @@
+ARG BUILDER_IMAGE=golang:1.26-alpine
+ARG RUNTIME_IMAGE=alpine:3.20
+
+FROM ${BUILDER_IMAGE} AS builder
+ARG GOPROXY=https://proxy.golang.org,direct
+ARG GOSUMDB=sum.golang.org
+WORKDIR /app
+ENV GOPROXY=${GOPROXY}
+ENV GOSUMDB=${GOSUMDB}
+COPY go.mod go.sum ./
+RUN go mod download || true
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=${TARGETARCH:-amd64} go build -o /out/worker ./cmd/worker
+
+FROM ${RUNTIME_IMAGE}
+WORKDIR /app
+COPY --from=builder /out/worker /usr/local/bin/worker
+COPY configs ./configs
+CMD ["/usr/local/bin/worker"]

biucingcli/template_data/worker/template/Dockerfile.dev

@@ -0,0 +1,9 @@
+FROM golang:1.26-alpine
+ARG GOPROXY=https://proxy.golang.org,direct
+ARG GOSUMDB=sum.golang.org
+WORKDIR /app
+ENV GOPROXY=${GOPROXY}
+ENV GOSUMDB=${GOSUMDB}
+COPY go.mod go.sum ./
+RUN go mod download || true
+CMD ["sh", "-lc", "go run ./cmd/worker"]