polyforge-cli 0.1.0

package/dist/core/renderer.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderProject = renderProject;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const TEXT_EXT = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".vue",
+    ".json",
+    ".md",
+    ".txt",
+    ".go",
+    ".mod",
+    ".sum",
+    ".java",
+    ".yml",
+    ".yaml",
+    ".xml",
+    ".properties",
+    ".env",
+    ".gitignore",
+    ".sh",
+    ".py",
+    ".toml",
+    ".cfg",
+    ".ini",
+    ".sql",
+    ".html",
+    ".css",
+]);
+function templateRoot() {
+    return path_1.default.resolve(__dirname, "..", "templates");
+}
+function replacements(config) {
+    return {
+        PROJECT_NAME: config.projectName,
+        BACKEND_MAIN: config.backendMain,
+        FRONTEND: config.frontend,
+        DATA_MODULES: config.dataModules.join(", "),
+        EXTRA_MODULES: config.extraModules.join(", ") || "none",
+        HAS_GATEWAY_BFF: String(config.extraModules.includes("gateway-bff")),
+    };
+}
+async function renderTextFile(file, map) {
+    const ext = path_1.default.extname(file);
+    const base = path_1.default.basename(file);
+    if (!TEXT_EXT.has(ext) && !TEXT_EXT.has(base))
+        return;
+    const content = await fs_extra_1.default.readFile(file, "utf8");
+    const rendered = content.replace(/\{\{([A-Z0-9_]+)\}\}/g, (_m, key) => map[key] ?? "");
+    if (content !== rendered) {
+        await fs_extra_1.default.writeFile(file, rendered, "utf8");
+    }
+}
+async function renderDir(target, map) {
+    const entries = await fs_extra_1.default.readdir(target, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path_1.default.join(target, entry.name);
+        if (entry.isDirectory()) {
+            await renderDir(full, map);
+        }
+        else {
+            await renderTextFile(full, map);
+        }
+    }
+}
+async function mergeTemplate(templateDir, targetDir, map) {
+    const source = path_1.default.join(templateRoot(), templateDir);
+    if (!(await fs_extra_1.default.pathExists(source)))
+        return;
+    await fs_extra_1.default.copy(source, targetDir, { overwrite: true });
+    await renderDir(targetDir, map);
+}
+async function ensureExecutableScripts(targetDir) {
+    const scripts = [
+        path_1.default.join(targetDir, "infra", "scripts", "dev.sh"),
+        path_1.default.join(targetDir, "infra", "scripts", "build.sh"),
+        path_1.default.join(targetDir, "infra", "scripts", "test.sh"),
+        path_1.default.join(targetDir, "infra", "scripts", "check.sh"),
+    ];
+    for (const script of scripts) {
+        if (await fs_extra_1.default.pathExists(script)) {
+            await fs_extra_1.default.chmod(script, 0o755);
+        }
+    }
+}
+function dockerServices(config) {
+    const services = [];
+    if (config.dataModules.includes("mysql")) {
+        services.push(`  mysql:\n    image: mysql:8\n    environment:\n      MYSQL_ROOT_PASSWORD: root\n      MYSQL_DATABASE: app\n    ports:\n      - \"3306:3306\"`);
+    }
+    if (config.dataModules.includes("postgresql")) {
+        services.push(`  postgresql:\n    image: postgres:16\n    environment:\n      POSTGRES_PASSWORD: postgres\n      POSTGRES_DB: app\n    ports:\n      - \"5432:5432\"`);
+    }
+    if (config.dataModules.includes("redis")) {
+        services.push(`  redis:\n    image: redis:7\n    ports:\n      - \"6379:6379\"`);
+    }
+    if (config.dataModules.includes("mongodb")) {
+        services.push(`  mongodb:\n    image: mongo:7\n    ports:\n      - \"27017:27017\"`);
+    }
+    if (config.extraModules.includes("python-worker")) {
+        services.push(`  worker-python:\n    build:\n      context: ../apps/worker-python\n    command: python worker.py`);
+    }
+    if (config.extraModules.includes("worker-go")) {
+        services.push(`  worker-go:\n    build:\n      context: ../apps/worker-go\n    command: go run ./cmd/worker`);
+    }
+    if (config.extraModules.includes("gateway-bff")) {
+        services.push(`  gateway-bff:\n    build:\n      context: ../apps/gateway-bff\n    command: node server.js\n    ports:\n      - "3001:3001"`);
+    }
+    if (config.extraModules.includes("python-ai")) {
+        services.push(`  python-ai:\n    build:\n      context: ../apps/python-ai\n    command: uvicorn app.main:app --host 0.0.0.0 --port 8090\n    ports:\n      - "8090:8090"`);
+    }
+    if (config.extraModules.includes("auth-center")) {
+        services.push(`  auth-center:\n    image: node:20-alpine\n    working_dir: /app\n    volumes:\n      - ../apps/auth-center:/app\n    command: node server.js\n    ports:\n      - "8081:8081"`);
+    }
+    return services.join("\n\n");
+}
+async function writeGeneratedReadme(config) {
+    const readme = `# ${config.projectName}\n\nGenerated by scaffold-hybrid-cli.\n\n## Stack\n- Frontend: ${config.frontend}\n- Backend: ${config.backendMain}\n- Extra modules: ${config.extraModules.join(", ") || "none"}\n- Data modules: ${config.dataModules.join(", ")}\n\n## Quick Start\n\n\`\`\`bash\n# basic sanity checks\nnpm run check\n\n# start local dev flow\nnpm run dev\n\n# build\nnpm run build\n\n# test\nnpm run test\n\`\`\`\n\nHealth endpoint: \`/health\`\n`;
+    await fs_extra_1.default.writeFile(path_1.default.join(config.targetDir, "README.md"), readme, "utf8");
+}
+async function updateGitignoreForSqlite(config) {
+    if (!config.dataModules.includes("sqlite"))
+        return;
+    const gitignorePath = path_1.default.join(config.targetDir, ".gitignore");
+    const exists = await fs_extra_1.default.pathExists(gitignorePath);
+    const marker = "data/*.db";
+    if (!exists) {
+        await fs_extra_1.default.writeFile(gitignorePath, `${marker}\n`, "utf8");
+        return;
+    }
+    const content = await fs_extra_1.default.readFile(gitignorePath, "utf8");
+    if (!content.includes(marker)) {
+        await fs_extra_1.default.writeFile(gitignorePath, `${content.trimEnd()}\n${marker}\n`, "utf8");
+    }
+}
+async function maybeWriteDocker(config) {
+    if (!config.docker)
+        return;
+    const dockerDir = path_1.default.join(config.targetDir, "infra", "docker");
+    await fs_extra_1.default.ensureDir(dockerDir);
+    const compose = `services:\n${dockerServices(config) || "  # add services here"}\n`;
+    await fs_extra_1.default.writeFile(path_1.default.join(dockerDir, "docker-compose.yml"), compose, "utf8");
+}
+async function renderProject(config) {
+    const target = config.targetDir;
+    if (await fs_extra_1.default.pathExists(target)) {
+        throw new Error(`target directory already exists: ${target}`);
+    }
+    await fs_extra_1.default.ensureDir(target);
+    const map = replacements(config);
+    await mergeTemplate("base", target, map);
+    await mergeTemplate(path_1.default.join("backend", config.backendMain), target, map);
+    if (config.frontend !== "none") {
+        await mergeTemplate(path_1.default.join("frontend", config.frontend), target, map);
+    }
+    for (const module of config.extraModules) {
+        await mergeTemplate(path_1.default.join("modules", module), target, map);
+    }
+    for (const data of config.dataModules) {
+        if (data === "none")
+            continue;
+        await mergeTemplate(path_1.default.join("data", data), target, map);
+    }
+    await maybeWriteDocker(config);
+    await updateGitignoreForSqlite(config);
+    await writeGeneratedReadme(config);
+    await ensureExecutableScripts(target);
+}

package/dist/core/validator.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = void 0;
+exports.parseCsv = parseCsv;
+exports.unique = unique;
+exports.parseDataModules = parseDataModules;
+exports.parseExtraModules = parseExtraModules;
+exports.validateConfig = validateConfig;
+const config_1 = require("../types/config");
+exports.DEFAULTS = {
+    frontend: "react",
+    backendMain: "go-gin",
+    extraModules: [],
+    dataModules: ["none"],
+    packageManager: "npm",
+    installDeps: false,
+    initGit: false,
+    docker: false,
+};
+function parseCsv(input) {
+    if (!input)
+        return [];
+    return input
+        .split(",")
+        .map((x) => x.trim())
+        .filter(Boolean);
+}
+function unique(arr) {
+    return [...new Set(arr)];
+}
+function parseDataModules(input) {
+    const parsed = parseCsv(input);
+    return parsed.filter((x) => config_1.DATA_MODULES.includes(x));
+}
+function parseExtraModules(input) {
+    const parsed = parseCsv(input);
+    return parsed.filter((x) => config_1.EXTRA_MODULES.includes(x));
+}
+function validateConfig(config) {
+    const errors = [];
+    const warnings = [];
+    if (!config.projectName.trim()) {
+        errors.push("projectName is required");
+    }
+    if (!config_1.FRONTENDS.includes(config.frontend)) {
+        errors.push(`unsupported frontend: ${config.frontend}`);
+    }
+    if (!config_1.BACKENDS.includes(config.backendMain)) {
+        errors.push(`unsupported backend: ${config.backendMain}`);
+    }
+    if (!config_1.PACKAGE_MANAGERS.includes(config.packageManager)) {
+        errors.push(`unsupported package manager: ${config.packageManager}`);
+    }
+    const uniqueData = unique(config.dataModules);
+    if (uniqueData.length !== config.dataModules.length) {
+        errors.push("data modules contain duplicates");
+    }
+    const uniqueModules = unique(config.extraModules);
+    if (uniqueModules.length !== config.extraModules.length) {
+        errors.push("extra modules contain duplicates");
+    }
+    const hasNone = config.dataModules.includes("none");
+    if (hasNone && config.dataModules.length > 1) {
+        errors.push("data=none cannot be combined with other data modules");
+    }
+    if (config.backendMain === "springboot" && config.dataModules.includes("sqlite")) {
+        warnings.push("springboot + sqlite is better for lightweight local scenarios");
+    }
+    if (config.extraModules.includes("python-worker")) {
+        warnings.push("python-worker selected: ensure Python 3.10+ and venv tooling are available");
+    }
+    if (config.extraModules.includes("python-ai")) {
+        warnings.push("python-ai selected: ensure Python 3.10+ and model runtime dependencies are available");
+    }
+    if (config.extraModules.includes("grpc-service")) {
+        warnings.push("grpc-service selected: install protoc and language plugins for code generation");
+    }
+    if (config.extraModules.includes("mq")) {
+        warnings.push("mq selected: verify local broker runtime (Kafka/RabbitMQ/NATS) for integration testing");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/dist/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const create_1 = require("./commands/create");
+const doctor_1 = require("./commands/doctor");
+const list_1 = require("./commands/list");
+const program = new commander_1.Command();
+program.name("scaffold").description("Hybrid full-stack scaffold CLI").version("0.1.0");
+program
+    .command("create")
+    .argument("<project-name>", "project name")
+    .option("--frontend <frontend>", "react|vue|none")
+    .option("--backend <backend>", "go-gin|springboot")
+    .option("--modules <modules>", "comma separated modules: python-worker,worker-go,gateway-bff,python-ai,grpc-service,mq,cache-redis,observability,auth-center")
+    .option("--data <data>", "comma separated data modules")
+    .option("--pm <pm>", "pnpm|npm|yarn")
+    .option("--install", "install dependencies")
+    .option("--git", "initialize git")
+    .option("--docker", "generate docker baseline")
+    .option("--yes", "use defaults for missing options")
+    .action(async (projectName, options) => {
+    try {
+        await (0, create_1.runCreate)(projectName, options);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(1);
+    }
+});
+program
+    .command("doctor")
+    .description("check local toolchain")
+    .option("--backend <backend>", "target backend for focused diagnostics: go-gin|springboot")
+    .option("--modules <modules>", "target extra modules, e.g. python-worker")
+    .option("--data <data>", "target data modules, e.g. mysql,redis")
+    .action(async (options) => {
+    await (0, doctor_1.runDoctor)(options);
+});
+program
+    .command("list")
+    .description("list supported templates/modules and defaults")
+    .action(async () => {
+    await (0, list_1.runList)();
+});
+program.parseAsync(process.argv);

package/dist/templates/backend/go-gin/apps/api/Makefile

@@ -0,0 +1,10 @@
+.PHONY: dev build test
+
+dev:
+	go run ./cmd/server
+
+build:
+	go build ./...
+
+test:
+	go test ./...

package/dist/templates/backend/go-gin/apps/api/cmd/server/main.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"log"
+
+	"github.com/gin-gonic/gin"
+
+	"{{PROJECT_NAME}}/apps/api/internal/config"
+	"{{PROJECT_NAME}}/apps/api/internal/handler"
+	"{{PROJECT_NAME}}/apps/api/internal/middleware"
+)
+
+func main() {
+	cfg := config.Load()
+
+	r := gin.New()
+	r.Use(middleware.TraceID())
+	r.Use(middleware.RequestLogger())
+	r.Use(middleware.Recover())
+
+	h := handler.New()
+	r.GET("/health", h.Health)
+	r.GET("/api/v1/ping", h.Ping)
+
+	log.Printf("api listening on :%s", cfg.Port)
+	if err := r.Run(":" + cfg.Port); err != nil {
+		log.Fatal(err)
+	}
+}

package/dist/templates/backend/go-gin/apps/api/go.mod

@@ -0,0 +1,5 @@
+module {{PROJECT_NAME}}/apps/api
+
+go 1.22
+
+require github.com/gin-gonic/gin v1.10.1

package/dist/templates/backend/go-gin/apps/api/internal/config/config.go

@@ -0,0 +1,22 @@
+package config
+
+import "os"
+
+type Config struct {
+	Port string
+	Env  string
+}
+
+func Load() Config {
+	return Config{
+		Port: getEnv("APP_PORT", "8080"),
+		Env:  getEnv("APP_ENV", "dev"),
+	}
+}
+
+func getEnv(key, fallback string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return fallback
+}

package/dist/templates/backend/go-gin/apps/api/internal/handler/health.go

@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"{{PROJECT_NAME}}/apps/api/internal/middleware"
+	"{{PROJECT_NAME}}/apps/api/internal/repository"
+	"{{PROJECT_NAME}}/apps/api/internal/service"
+	"{{PROJECT_NAME}}/apps/api/pkg/response"
+)
+
+type Handler struct {
+	pingService *service.PingService
+}
+
+func New() *Handler {
+	repo := repository.NewPingRepository()
+	return &Handler{
+		pingService: service.NewPingService(repo),
+	}
+}
+
+func (h *Handler) Health(c *gin.Context) {
+	traceID, _ := c.Get(middleware.TraceIDKey)
+	response.Success(c, http.StatusOK, gin.H{"status": "ok"}, traceIDString(traceID))
+}

package/dist/templates/backend/go-gin/apps/api/internal/handler/helpers.go

@@ -0,0 +1,8 @@
+package handler
+
+func traceIDString(v any) string {
+	if s, ok := v.(string); ok {
+		return s
+	}
+	return ""
+}

package/dist/templates/backend/go-gin/apps/api/internal/handler/ping.go

@@ -0,0 +1,15 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"{{PROJECT_NAME}}/apps/api/internal/middleware"
+	"{{PROJECT_NAME}}/apps/api/pkg/response"
+)
+
+func (h *Handler) Ping(c *gin.Context) {
+	traceID, _ := c.Get(middleware.TraceIDKey)
+	result := h.pingService.Ping()
+	response.Success(c, http.StatusOK, gin.H{"message": result}, traceIDString(traceID))
+}

package/dist/templates/backend/go-gin/apps/api/internal/middleware/logger.go

@@ -0,0 +1,18 @@
+package middleware
+
+import (
+	"log"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RequestLogger() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		c.Next()
+		latency := time.Since(start)
+		traceID, _ := c.Get(TraceIDKey)
+		log.Printf("traceId=%v method=%s path=%s status=%d latency=%s", traceID, c.Request.Method, c.Request.URL.Path, c.Writer.Status(), latency)
+	}
+}

package/dist/templates/backend/go-gin/apps/api/internal/middleware/recovery.go

@@ -0,0 +1,23 @@
+package middleware
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"{{PROJECT_NAME}}/apps/api/pkg/response"
+)
+
+func Recover() gin.HandlerFunc {
+	return gin.CustomRecovery(func(c *gin.Context, recovered any) {
+		traceID, _ := c.Get(TraceIDKey)
+		response.Error(c, http.StatusInternalServerError, 10000, "internal server error", traceIDString(traceID))
+		c.Abort()
+	})
+}
+
+func traceIDString(v any) string {
+	if s, ok := v.(string); ok {
+		return s
+	}
+	return ""
+}

package/dist/templates/backend/go-gin/apps/api/internal/middleware/trace.go

@@ -0,0 +1,28 @@
+package middleware
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+
+	"github.com/gin-gonic/gin"
+)
+
+const TraceIDKey = "traceId"
+
+func TraceID() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		traceID := c.GetHeader("X-Trace-Id")
+		if traceID == "" {
+			traceID = generateTraceID()
+		}
+		c.Set(TraceIDKey, traceID)
+		c.Writer.Header().Set("X-Trace-Id", traceID)
+		c.Next()
+	}
+}
+
+func generateTraceID() string {
+	b := make([]byte, 8)
+	_, _ = rand.Read(b)
+	return hex.EncodeToString(b)
+}

package/dist/templates/backend/go-gin/apps/api/internal/repository/ping.go

@@ -0,0 +1,11 @@
+package repository
+
+type PingRepo struct{}
+
+func NewPingRepository() *PingRepo {
+	return &PingRepo{}
+}
+
+func (r *PingRepo) Message() string {
+	return "pong"
+}

package/dist/templates/backend/go-gin/apps/api/internal/service/ping.go

@@ -0,0 +1,17 @@
+package service
+
+type PingRepository interface {
+	Message() string
+}
+
+type PingService struct {
+	repo PingRepository
+}
+
+func NewPingService(repo PingRepository) *PingService {
+	return &PingService{repo: repo}
+}
+
+func (s *PingService) Ping() string {
+	return s.repo.Message()
+}

package/dist/templates/backend/go-gin/apps/api/pkg/response/response.go

@@ -0,0 +1,35 @@
+package response
+
+import (
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+type Payload struct {
+	Code      int         `json:"code"`
+	Message   string      `json:"message"`
+	Data      interface{} `json:"data"`
+	TraceID   string      `json:"traceId"`
+	Timestamp string      `json:"timestamp"`
+}
+
+func Success(c *gin.Context, status int, data interface{}, traceID string) {
+	c.JSON(status, Payload{
+		Code:      0,
+		Message:   "success",
+		Data:      data,
+		TraceID:   traceID,
+		Timestamp: time.Now().UTC().Format(time.RFC3339),
+	})
+}
+
+func Error(c *gin.Context, status int, code int, message string, traceID string) {
+	c.JSON(status, Payload{
+		Code:      code,
+		Message:   message,
+		Data:      nil,
+		TraceID:   traceID,
+		Timestamp: time.Now().UTC().Format(time.RFC3339),
+	})
+}

package/dist/templates/backend/go-gin/apps/api/pkg/response/response_test.go

@@ -0,0 +1,21 @@
+package response
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+)
+
+func TestSuccess(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+
+	Success(c, http.StatusOK, gin.H{"x": 1}, "tid")
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("unexpected status: %d", w.Code)
+	}
+}

package/dist/templates/backend/springboot/apps/api/pom.xml

@@ -0,0 +1,44 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>3.3.5</version>
+    <relativePath/>
+  </parent>
+
+  <groupId>com.scaffold</groupId>
+  <artifactId>api</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+  <name>{{PROJECT_NAME}}-api</name>
+  <description>Spring Boot API generated by scaffold</description>
+  <properties>
+    <java.version>17</java.version>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-actuator</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-test</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
+</project>

package/dist/templates/backend/springboot/apps/api/src/main/java/com/scaffold/api/Application.java

@@ -0,0 +1,11 @@
+package com.scaffold.api;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Application {
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}

package/dist/templates/backend/springboot/apps/api/src/main/java/com/scaffold/api/common/ApiResponse.java

@@ -0,0 +1,19 @@
+package com.scaffold.api.common;
+
+import java.time.Instant;
+
+public record ApiResponse<T>(
+        int code,
+        String message,
+        T data,
+        String traceId,
+        String timestamp
+) {
+    public static <T> ApiResponse<T> success(T data, String traceId) {
+        return new ApiResponse<>(0, "success", data, traceId, Instant.now().toString());
+    }
+
+    public static <T> ApiResponse<T> error(int code, String message, String traceId) {
+        return new ApiResponse<>(code, message, null, traceId, Instant.now().toString());
+    }
+}