gorig-cli 1.0.24 → 1.0.26

package/commands/skill.js

@@ -15,41 +15,73 @@ const printUsage = () => {
   console.log(chalk.yellow('Usage: gorig-cli skill install <codex|claude|all> [user|project]'));
 };
 
-const installSkill = async (target, scope) => {
-  const templateRoot = path.join(__dirname, '../templates/skills');
+export const resolveInstalls = (target, scope, options = {}) => {
+  const cwd = options.cwd || process.cwd();
+  const home = options.home || os.homedir();
+  const templateRoot = options.templateRoot || path.join(__dirname, '../templates/skills');
+  const source = path.join(templateRoot, SKILL_NAME);
   const installs = [];
 
   if (target === 'codex' || target === 'all') {
-    const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+    const codexBase = scope === 'project'
+      ? path.join(cwd, '.agents')
+      : path.join(home, '.agents');
+
     installs.push({
-      label: 'Codex',
-      source: path.join(templateRoot, 'codex', SKILL_NAME),
-      destination: path.join(codexHome, 'skills', SKILL_NAME),
+      label: `Codex (${scope})`,
+      source,
+      destination: path.join(codexBase, 'skills', SKILL_NAME),
     });
   }
 
   if (target === 'claude' || target === 'all') {
     const claudeBase = scope === 'project'
-      ? path.join(process.cwd(), '.claude')
-      : path.join(os.homedir(), '.claude');
+      ? path.join(cwd, '.claude')
+      : path.join(home, '.claude');
 
     installs.push({
       label: `Claude (${scope})`,
-      source: path.join(templateRoot, 'claude', SKILL_NAME),
+      source,
       destination: path.join(claudeBase, 'skills', SKILL_NAME),
     });
   }
 
+  return installs;
+};
+
+export const installSkill = async (target, scope, options = {}) => {
+  const installs = resolveInstalls(target, scope, options);
+
   for (const install of installs) {
     const exists = await fs.pathExists(install.source);
     if (!exists) {
       throw new Error(`Skill template not found: ${install.source}`);
     }
+  }
+
+  const staged = [];
+
+  try {
+    for (const install of installs) {
+      const temporary = `${install.destination}.tmp-${process.pid}-${Date.now()}`;
+      await fs.remove(temporary);
+      await fs.ensureDir(path.dirname(temporary));
+      await fs.copy(install.source, temporary, { overwrite: true });
+      staged.push({ ...install, temporary });
+    }
 
-    await fs.ensureDir(path.dirname(install.destination));
-    await fs.copy(install.source, install.destination, { overwrite: true });
-    console.log(chalk.green(`Installed ${install.label} skill to ${install.destination}`));
+    for (const install of staged) {
+      await fs.ensureDir(path.dirname(install.destination));
+      await fs.remove(install.destination);
+      await fs.move(install.temporary, install.destination);
+      console.log(chalk.green(`Installed ${install.label} skill to ${install.destination}`));
+    }
+  } catch (error) {
+    await Promise.all(staged.map(({ temporary }) => fs.remove(temporary)));
+    throw error;
   }
+
+  return installs;
 };
 
 const skillModule = async (args) => {
@@ -57,13 +89,15 @@ const skillModule = async (args) => {
 
   if (!action) {
     printUsage();
-    process.exit(1);
+    process.exitCode = 1;
+    return 1;
   }
 
   if (action !== 'install') {
     console.error(chalk.red(`Unknown skill action: ${action}`));
     printUsage();
-    process.exit(1);
+    process.exitCode = 1;
+    return 1;
   }
 
   const target = args[1] || 'all';
@@ -72,20 +106,24 @@ const skillModule = async (args) => {
   if (!VALID_TARGETS.has(target)) {
     console.error(chalk.red(`Unknown skill target: ${target}`));
     printUsage();
-    process.exit(1);
+    process.exitCode = 1;
+    return 1;
   }
 
   if (!VALID_SCOPES.has(scope)) {
     console.error(chalk.red(`Unknown skill scope: ${scope}`));
     printUsage();
-    process.exit(1);
+    process.exitCode = 1;
+    return 1;
   }
 
   try {
     await installSkill(target, scope);
+    return 0;
   } catch (error) {
     console.error(chalk.red('Failed to install skill:'), chalk.redBright(error.message));
-    process.exit(1);
+    process.exitCode = 1;
+    return 1;
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gorig-cli",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "type": "module",
   "description": "gorig build tool",
   "main": "bin/cli.js",

package/templates/config.go.ejs

@@ -1,14 +1,15 @@
 package global
 
-import (
-	configure "github.com/jom-io/gorig/utils/cofigure"
-)
+import configure "github.com/jom-io/gorig/utils/cofigure"
 
 var (
-	DBDef    = "def"
 	SysName  = ""
+	RunMode  = ""
+	RestAddr = ""
 )
 
 func init() {
-	SysName = configure.GetString("sys.name", "TEST")
+	SysName = configure.GetString("sys.name", "<%= projectNameUpper %>")
+	RunMode = configure.GetString("sys.mode", "local")
+	RestAddr = configure.GetString("api.rest.addr", ":<%= localPort %>")
 }

package/templates/config.yaml.ejs

@@ -4,42 +4,7 @@ sys:
 
 api:
   rest:
-    addr: :9527
+    addr: ":<%= port %>"
 
-#db:
-#  prefix: <%= projectPrefix %>_
-
-#mongo:
-#  Main:
-#    uri: mongodb://addr
-#    auth:
-#      need: true
-#      source: db_source
-#      user: user
-#      password: pwd
-#    db:
-#      name: db_name
-#
-#Mysql:
-#  Main:
-#    GormInit: 1
-#    SlowThreshold: 30  # Slow SQL threshold (sysql execution time exceeds this time unit (second), system logging will be triggered)
-#    Write:
-#      Host: addr
-#      DataBase: db_name
-#      Port: 3306
-#      User: user
-#      Pass: pwd
-#      Charset: "utf8"
-#      SetMaxIdleConns: 10
-#      SetMaxOpenConns: 128
-#      SetConnMaxLifetime: 60 # Maximum survival time when connection is inactive (seconds)
-
-#redis:
-#  addr: localhost:6379
-#  password:
-#  db: 0
-
-#notify:
-#  dingding:
-#    token: xxxxx
+# Add database, Redis, and notification configuration only when the project uses them.
+# Prefer GORIG_<SECTION>_<KEY> environment variables for secrets.

package/templates/controller.go.ejs

@@ -4,59 +4,28 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/jom-io/gorig/apix"
 	"github.com/jom-io/gorig/global/consts"
-	"<%= projectName %>/domain/<%= moduleName %>/api/req"
 )
 
-func Page<%= ModuleName %>(ctx *gin.Context) {
+func Info(ctx *gin.Context) {
 	defer apix.HandlePanic(ctx)
-	pageReq, e := apix.GetPageReq(ctx)
-	filter := &req.<%= ModuleName %>Req{}
-	e = apix.BindParams(ctx, filter)
-	if e != nil {
-		return
-	}
-	result, err := gService.Page<%= ModuleName %>(ctx, pageReq, filter)
-	apix.HandleData(ctx, consts.CurdSelectFailCode, &result, err)
-}
 
-func List<%= ModuleName %>(ctx *gin.Context) {
-	defer apix.HandlePanic(ctx)
-	filter := &req.<%= ModuleName %>Req{}
-	e := apix.BindParams(ctx, filter)
-	if e != nil {
+	name, err := apix.GetParamType[string](ctx, "name", apix.NotForce, "world")
+	if err != nil {
 		return
 	}
-	result, err := gService.List<%= ModuleName %>(ctx, filter)
-	apix.HandleData(ctx, consts.CurdSelectFailCode, &result, err)
-}
 
-func Save<%= ModuleName %>(ctx *gin.Context) {
-	defer apix.HandlePanic(ctx)
-	<%= moduleName %>Req := &req.<%= ModuleName %>Req{}
-	e := apix.BindParams(ctx, <%= moduleName %>Req)
-	if e != nil {
-		return
-	}
-	err := gService.Save<%= ModuleName %>(ctx, <%= moduleName %>Req)
-	apix.HandleData(ctx, consts.CurdUpdateFailCode, nil, err)
+	result, serviceErr := BuildInfo(ctx, name)
+	apix.HandleData(ctx, consts.CurdSelectFailCode, result, serviceErr)
 }
 
-func Get<%= ModuleName %>(ctx *gin.Context) {
+func Echo(ctx *gin.Context) {
 	defer apix.HandlePanic(ctx)
-	id, e := apix.GetParamInt64(ctx, "id", apix.Force)
-	if e != nil {
-		return
-	}
-	result, err := gService.Get<%= ModuleName %>(ctx, id)
-	apix.HandleData(ctx, consts.CurdSelectFailCode, &result, err)
-}
 
-func Delete<%= ModuleName %>(ctx *gin.Context) {
-	defer apix.HandlePanic(ctx)
-	id, e := apix.GetParamInt64(ctx, "id", apix.Force)
-	if e != nil {
+	req := &EchoReq{}
+	if err := apix.BindParams(ctx, req); err != nil {
 		return
 	}
-	err := gService.Delete<%= ModuleName %>(ctx, id)
-	apix.HandleData(ctx, consts.CurdUpdateFailCode, nil, err)
+
+	result, serviceErr := EchoMessage(ctx, req)
+	apix.HandleData(ctx, consts.CurdSelectFailCode, result, serviceErr)
 }

package/templates/crud.controller.go.ejs

@@ -0,0 +1,71 @@
+package <%= moduleName %>
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/jom-io/gorig/apix"
+	"github.com/jom-io/gorig/global/consts"
+)
+
+func CreateHTTP(ctx *gin.Context) {
+	defer apix.HandlePanic(ctx)
+	req := &CreateReq{}
+	if err := apix.BindParams(ctx, req); err != nil {
+		return
+	}
+	id, err := Create(ctx, req)
+	apix.HandleData(ctx, consts.CurdUpdateFailCode, id, err)
+}
+
+func InfoHTTP(ctx *gin.Context) {
+	defer apix.HandlePanic(ctx)
+	id, err := apix.GetParamInt64(ctx, "id", apix.Force)
+	if err != nil {
+		return
+	}
+	resp, serviceErr := Info(ctx, id)
+	apix.HandleData(ctx, consts.CurdSelectFailCode, resp, serviceErr)
+}
+
+func ListHTTP(ctx *gin.Context) {
+	defer apix.HandlePanic(ctx)
+	req := &QueryReq{}
+	if err := apix.BindParams(ctx, req); err != nil {
+		return
+	}
+	resp, serviceErr := List(ctx, req)
+	apix.HandleData(ctx, consts.CurdSelectFailCode, resp, serviceErr)
+}
+
+func PageHTTP(ctx *gin.Context) {
+	defer apix.HandlePanic(ctx)
+	pageReq, err := apix.GetPageReq(ctx)
+	if err != nil {
+		return
+	}
+	req := &QueryReq{}
+	if err = apix.BindParams(ctx, req); err != nil {
+		return
+	}
+	resp, serviceErr := Page(ctx, req, pageReq)
+	apix.HandleData(ctx, consts.CurdSelectFailCode, resp, serviceErr)
+}
+
+func UpdateHTTP(ctx *gin.Context) {
+	defer apix.HandlePanic(ctx)
+	req := &UpdateReq{}
+	if err := apix.BindParams(ctx, req); err != nil {
+		return
+	}
+	err := Update(ctx, req)
+	apix.HandleData(ctx, consts.CurdUpdateFailCode, nil, err)
+}
+
+func DeleteHTTP(ctx *gin.Context) {
+	defer apix.HandlePanic(ctx)
+	id, err := apix.GetParamInt64(ctx, "id", apix.Force)
+	if err != nil {
+		return
+	}
+	serviceErr := Delete(ctx, id)
+	apix.HandleData(ctx, consts.CurdUpdateFailCode, nil, serviceErr)
+}

package/templates/crud.doc.md.ejs

@@ -0,0 +1,60 @@
+# <%= ModuleName %> API
+
+Persistent CRUD HTTP API backed by <%= dbTitle %>.
+
+## POST /<%= moduleName %>/create
+
+Request:
+
+```json
+{
+  "name": "demo",
+  "status": "enabled",
+  "remark": "optional"
+}
+```
+
+Response data: created numeric ID.
+
+## GET /<%= moduleName %>/info
+
+Query:
+
+| Name | Required | Description |
+|---|---|---|
+| id | yes | Record ID |
+
+## GET /<%= moduleName %>/list
+
+Optional filters: `name`, `status`.
+
+## GET /<%= moduleName %>/page
+
+Optional filters: `name`, `status`, `page`, `size`, `lastID`.
+
+## POST /<%= moduleName %>/update
+
+Request:
+
+```json
+{
+  "id": 1,
+  "name": "new name",
+  "status": "disabled",
+  "remark": "updated"
+}
+```
+
+## DELETE /<%= moduleName %>/delete
+
+Query:
+
+| Name | Required | Description |
+|---|---|---|
+| id | yes | Record ID |
+
+## Error cases
+
+- `400`: missing ID, missing name, invalid status, or no update fields
+- `404`: record not found
+- `409`: name already exists

package/templates/crud.dto.go.ejs

@@ -0,0 +1,103 @@
+package <%= moduleName %>
+
+import (
+	"strings"
+
+	"github.com/jom-io/gorig/utils/errors"
+)
+
+const (
+	StatusEnabled  = "enabled"
+	StatusDisabled = "disabled"
+)
+
+type CreateReq struct {
+	Name   string `json:"name" form:"name"`
+	Status string `json:"status" form:"status"`
+	Remark string `json:"remark" form:"remark"`
+}
+
+type UpdateReq struct {
+	ID     int64  `json:"id" form:"id"`
+	Name   string `json:"name" form:"name"`
+	Status string `json:"status" form:"status"`
+	Remark string `json:"remark" form:"remark"`
+}
+
+type QueryReq struct {
+	Name   string `json:"name" form:"name"`
+	Status string `json:"status" form:"status"`
+}
+
+type Resp struct {
+	ID     int64  `json:"id"`
+	Name   string `json:"name"`
+	Status string `json:"status"`
+	Remark string `json:"remark"`
+}
+
+func normalizeStatus(status string) string {
+	status = strings.TrimSpace(status)
+	if status == "" {
+		return StatusEnabled
+	}
+	return status
+}
+
+func validStatus(status string) bool {
+	return status == StatusEnabled || status == StatusDisabled
+}
+
+func (r *CreateReq) Validate() *errors.Error {
+	if r == nil {
+		return errors.VerifyCode(400, "request is required")
+	}
+	r.Name = strings.TrimSpace(r.Name)
+	r.Status = normalizeStatus(r.Status)
+	r.Remark = strings.TrimSpace(r.Remark)
+	if r.Name == "" {
+		return errors.VerifyCode(400, "name is required")
+	}
+	if !validStatus(r.Status) {
+		return errors.VerifyCode(400, "status is invalid")
+	}
+	return nil
+}
+
+func (r *UpdateReq) Updates() (map[string]interface{}, *errors.Error) {
+	if r == nil {
+		return nil, errors.VerifyCode(400, "request is required")
+	}
+	if r.ID <= 0 {
+		return nil, errors.VerifyCode(400, "id is required")
+	}
+	updates := map[string]interface{}{}
+	if name := strings.TrimSpace(r.Name); name != "" {
+		updates["name"] = name
+	}
+	if status := strings.TrimSpace(r.Status); status != "" {
+		if !validStatus(status) {
+			return nil, errors.VerifyCode(400, "status is invalid")
+		}
+		updates["status"] = status
+	}
+	if remark := strings.TrimSpace(r.Remark); remark != "" {
+		updates["remark"] = remark
+	}
+	if len(updates) == 0 {
+		return nil, errors.VerifyCode(400, "no update fields")
+	}
+	return updates, nil
+}
+
+func (r *QueryReq) Normalize() *errors.Error {
+	if r == nil {
+		return nil
+	}
+	r.Name = strings.TrimSpace(r.Name)
+	r.Status = strings.TrimSpace(r.Status)
+	if r.Status != "" && !validStatus(r.Status) {
+		return errors.VerifyCode(400, "status is invalid")
+	}
+	return nil
+}

package/templates/crud.integration.init_test.go.ejs

@@ -0,0 +1,17 @@
+//go:build integration && <%= db %>
+
+package test
+
+import "github.com/jom-io/gorig/domainx"
+
+func init() {
+<% if (db === 'mysql') { -%>
+	if err := domainx.GormDBServ.Start(); err != nil {
+		panic(err)
+	}
+<% } else { -%>
+	if err := domainx.MongoDBServ.Start(); err != nil {
+		panic(err)
+	}
+<% } -%>
+}

package/templates/crud.integration_test.go.ejs

@@ -0,0 +1,66 @@
+//go:build integration && <%= db %>
+
+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"<%= projectName %>/domain/<%= moduleName %>"
+
+	"github.com/jom-io/gorig/apix/load"
+)
+
+func Test<%= ModuleName %>IntegrationCRUD(t *testing.T) {
+	ctx := context.Background()
+	name := fmt.Sprintf("<%= moduleName %>-%d", time.Now().UnixNano())
+
+	id, err := <%= moduleName %>.Create(ctx, &<%= moduleName %>.CreateReq{
+		Name:   name,
+		Status: <%= moduleName %>.StatusEnabled,
+		Remark: "integration",
+	})
+	if err != nil {
+		t.Fatalf("Create failed: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = <%= moduleName %>.Delete(ctx, id)
+	})
+
+	info, err := <%= moduleName %>.Info(ctx, id)
+	if err != nil || info == nil || info.Name != name {
+		t.Fatalf("Info failed: info=%+v err=%v", info, err)
+	}
+
+	list, err := <%= moduleName %>.List(ctx, &<%= moduleName %>.QueryReq{Name: name})
+	if err != nil || len(list) != 1 || list[0].ID != id {
+		t.Fatalf("List failed: list=%+v err=%v", list, err)
+	}
+
+	page, err := <%= moduleName %>.Page(ctx, &<%= moduleName %>.QueryReq{Name: name}, load.BuildPage(ctx, 1, 10, 0))
+	if err != nil || page == nil {
+		t.Fatalf("Page failed: page=%+v err=%v", page, err)
+	}
+	pageItems, ok := page.Result.([]*<%= moduleName %>.Resp)
+	if !ok || len(pageItems) != 1 || pageItems[0].ID != id {
+		t.Fatalf("Page result failed: result=%+v", page.Result)
+	}
+
+	if err := <%= moduleName %>.Update(ctx, &<%= moduleName %>.UpdateReq{
+		ID:     id,
+		Status: <%= moduleName %>.StatusDisabled,
+	}); err != nil {
+		t.Fatalf("Update failed: %v", err)
+	}
+
+	updated, err := <%= moduleName %>.Info(ctx, id)
+	if err != nil || updated == nil || updated.Status != <%= moduleName %>.StatusDisabled {
+		t.Fatalf("updated Info failed: info=%+v err=%v", updated, err)
+	}
+
+	if err := <%= moduleName %>.Delete(ctx, id); err != nil {
+		t.Fatalf("Delete failed: %v", err)
+	}
+}

package/templates/crud.model.go.ejs

@@ -0,0 +1,25 @@
+package model
+
+import "github.com/jom-io/gorig/domainx"
+
+const Table = "<%= moduleName %>"
+
+type D struct {
+<% if (db === 'mysql') { -%>
+	Name   string `gorm:"column:name;type:varchar(128);not null" json:"name" form:"name"`
+	Status string `gorm:"column:status;type:varchar(32);not null" json:"status" form:"status"`
+	Remark string `gorm:"column:remark;type:varchar(512)" json:"remark" form:"remark"`
+<% } else { -%>
+	Name   string `bson:"name" json:"name" form:"name"`
+	Status string `bson:"status" json:"status" form:"status"`
+	Remark string `bson:"remark" json:"remark" form:"remark"`
+<% } -%>
+}
+
+func (*D) DConfig() (domainx.ConType, string, string) {
+<% if (db === 'mysql') { -%>
+	return domainx.Mysql, "<%= dbName %>", Table
+<% } else { -%>
+	return domainx.Mongo, "<%= dbName %>", Table
+<% } -%>
+}

package/templates/crud.module.README.md.ejs

@@ -0,0 +1,70 @@
+# <%= moduleName %> module
+
+Persistent CRUD module generated for <%= dbTitle %>.
+
+## Storage
+
+- Backend: <%= dbTitle %>
+- Database: `<%= dbName %>`
+- Table/collection: `<%= moduleName %>`
+- Unique index: `name`
+- Normal index: `status`
+
+## Configuration
+
+The generator adds a non-secret `<% if (db === 'mysql') { %>Mysql.<%= dbName %><% } else { %>mongo.<%= dbName %><% } %>` connection skeleton to `_bin/local.yaml`, `_bin/dev.yaml`, `_bin/prod.yaml`, and `test/_bin/local.yaml`.
+
+Before integration testing, replace the local placeholder connection values or set environment variables:
+
+<% if (db === 'mysql') { -%>
+- `GORIG_MYSQL_<%= dbEnvName %>_WRITE_HOST`
+- `GORIG_MYSQL_<%= dbEnvName %>_WRITE_PORT`
+- `GORIG_MYSQL_<%= dbEnvName %>_WRITE_DATABASE`
+- `GORIG_MYSQL_<%= dbEnvName %>_WRITE_USER`
+- `GORIG_MYSQL_<%= dbEnvName %>_WRITE_PASS`
+<% } else { -%>
+- `GORIG_MONGO_<%= dbEnvName %>_URI`
+- `GORIG_MONGO_<%= dbEnvName %>_DB_NAME`
+- `GORIG_MONGO_<%= dbEnvName %>_AUTH_SOURCE`
+- `GORIG_MONGO_<%= dbEnvName %>_AUTH_USER`
+- `GORIG_MONGO_<%= dbEnvName %>_AUTH_PASSWORD`
+<% } -%>
+
+Tests normally load `test/_bin/local.yaml` because the Go test package runs with `test/` as its working directory. Do not put real production credentials in committed YAML.
+
+## Service operations
+
+- `Create(ctx, req)`
+- `Info(ctx, id)`
+- `List(ctx, req)`
+- `Page(ctx, req, pageReq)`
+- `Update(ctx, req)`
+- `Delete(ctx, id)`
+
+<% if (http) { -%>
+## HTTP routes
+
+- POST `/<%= moduleName %>/create`
+- GET `/<%= moduleName %>/info?id=`
+- GET `/<%= moduleName %>/list`
+- GET `/<%= moduleName %>/page?page=1&size=10`
+- POST `/<%= moduleName %>/update`
+- DELETE `/<%= moduleName %>/delete?id=`
+<% } -%>
+
+## Verification
+
+```sh
+go fmt ./...
+go vet ./...
+go build ./...
+go test ./... -v
+```
+
+Database integration requires a reachable <%= dbTitle %> connection for `<%= dbName %>`:
+
+```sh
+go test -tags=integration,<%= db %> ./test/... -v
+```
+
+The integration build tag keeps ordinary unit tests independent of external database availability.