gorig-cli 1.0.14 → 1.0.23

package/README.md

@@ -72,6 +72,33 @@ npx gorig-cli@latest doc user
 After generating the documentation, you can access it through:
 http://127.0.0.1:8080/redoc.html
 
+### Install Gorig Skill
+
+Use the `skill` command to install the bundled `gorig-backend` skill for Codex or Claude:
+
+```sh
+# Install both Codex and Claude user-level skills
+gorig-cli skill install all
+
+# Install only the Codex skill
+gorig-cli skill install codex
+
+# Install Claude user-level skill
+gorig-cli skill install claude user
+
+# Install Claude project-level skill into the current repository
+gorig-cli skill install claude project
+```
+
+Or use npx:
+
+```sh
+npx gorig-cli@latest skill install all
+npx gorig-cli@latest skill install codex
+npx gorig-cli@latest skill install claude user
+npx gorig-cli@latest skill install claude project
+```
+
 ### Run the Project
 
 After entering the project directory, you can run the project using the following commands:
@@ -86,4 +113,3 @@ Or run it after building:
 ```sh
 go build -o my-new-project _cmd/main.go && ./my-new-project
 ```
-

package/bin/cli.js

@@ -3,53 +3,62 @@
 import chalk from 'chalk';
 import path from 'path';
 
-// 获取命令行参数
+// Get command line arguments
 const args = process.argv.slice(2);
 
-// 验证是否提供了命令
+// Validate if a command is provided
 if (args.length < 1) {
-  console.error(chalk.red('请提供一个有效的命令，例如: create 或 init'));
+  console.error(chalk.red('Please provide a valid command, e.g.: create, init, doc, or skill'));
   process.exit(1);
 }
 
-// 提取命令
+// Extract command
 const command = args[0];
 
-// 获取当前文件的目录
+// Get current file directory
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 
-// 根据命令执行不同的逻辑
+// Execute different logic based on command
 switch (command) {
   case 'create':
-    // 动态导入 create.js，命令放在 commands 目录下
+    // Dynamically import create.js, commands are placed in the commands directory
     import(path.join(__dirname, '../commands/create.js')).then(module => {
       const createModule = module.default;
-      createModule(args.slice(1));  // 将命令行的其他参数传递给 create.js
+      createModule(args.slice(1));  // Pass other command line arguments to create.js
     }).catch(error => {
-      console.error(chalk.red('无法加载 create 命令模块:', error.message));
+      console.error(chalk.red('Failed to load create command module:', error.message));
     });
     break;
 
   case 'init':
-    // 动态导入 init.js
+    // Dynamically import init.js
     import(path.join(__dirname, '../commands/init.js')).then(module => {
       const initModule = module.default;
-      initModule(args.slice(1));  // 将命令行的其他参数传递给 init.js
+      initModule(args.slice(1));  // Pass other command line arguments to init.js
     }).catch(error => {
-      console.error(chalk.red('无法加载 init 命令模块:', error.message));
+      console.error(chalk.red('Failed to load init command module:', error.message));
     });
     break;
   case 'doc':
     import(path.join(__dirname, '../commands/doc.js')).then(module => {
       const docModule = module.default;
-      docModule();  // 执行 doc 命令
+      docModule();  // Execute doc command
     }).catch(error => {
-      console.error(chalk.red('无法加载 doc 命令模块:', error.message));
+      console.error(chalk.red('Failed to load doc command module:', error.message));
+    });
+    break;
+
+  case 'skill':
+    import(path.join(__dirname, '../commands/skill.js')).then(module => {
+      const skillModule = module.default;
+      skillModule(args.slice(1));
+    }).catch(error => {
+      console.error(chalk.red('Failed to load skill command module:', error.message));
     });
     break;
 
   default:
-    console.error(chalk.red(`未知的命令: ${command}`));
-    console.error(chalk.yellow('可用的命令: create, init'));
+    console.error(chalk.red(`Unknown command: ${command}`));
+    console.error(chalk.yellow('Available commands: create, init, doc, skill'));
     process.exit(1);
 }

package/commands/skill.js

@@ -0,0 +1,92 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const SKILL_NAME = 'gorig-backend';
+const VALID_TARGETS = new Set(['codex', 'claude', 'all']);
+const VALID_SCOPES = new Set(['user', 'project']);
+
+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');
+  const installs = [];
+
+  if (target === 'codex' || target === 'all') {
+    const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+    installs.push({
+      label: 'Codex',
+      source: path.join(templateRoot, 'codex', SKILL_NAME),
+      destination: path.join(codexHome, 'skills', SKILL_NAME),
+    });
+  }
+
+  if (target === 'claude' || target === 'all') {
+    const claudeBase = scope === 'project'
+      ? path.join(process.cwd(), '.claude')
+      : path.join(os.homedir(), '.claude');
+
+    installs.push({
+      label: `Claude (${scope})`,
+      source: path.join(templateRoot, 'claude', SKILL_NAME),
+      destination: path.join(claudeBase, 'skills', SKILL_NAME),
+    });
+  }
+
+  for (const install of installs) {
+    const exists = await fs.pathExists(install.source);
+    if (!exists) {
+      throw new Error(`Skill template not found: ${install.source}`);
+    }
+
+    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}`));
+  }
+};
+
+const skillModule = async (args) => {
+  const action = args[0];
+
+  if (!action) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (action !== 'install') {
+    console.error(chalk.red(`Unknown skill action: ${action}`));
+    printUsage();
+    process.exit(1);
+  }
+
+  const target = args[1] || 'all';
+  const scope = args[2] || 'user';
+
+  if (!VALID_TARGETS.has(target)) {
+    console.error(chalk.red(`Unknown skill target: ${target}`));
+    printUsage();
+    process.exit(1);
+  }
+
+  if (!VALID_SCOPES.has(scope)) {
+    console.error(chalk.red(`Unknown skill scope: ${scope}`));
+    printUsage();
+    process.exit(1);
+  }
+
+  try {
+    await installSkill(target, scope);
+  } catch (error) {
+    console.error(chalk.red('Failed to install skill:'), chalk.redBright(error.message));
+    process.exit(1);
+  }
+};
+
+export default skillModule;

package/npm_publish copy.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+# 确保脚本有执行权限
+# chmod +x npm_publish.sh
+
+# 设置官方源地址和原仓库源地址
+NPM_OFFICIAL_REGISTRY="https://registry.npmjs.org/"
+CUSTOM_REGISTRY=$(npm config get registry)
+
+# 检查原始仓库源是否为官方源
+if [ "$CUSTOM_REGISTRY" = "$NPM_OFFICIAL_REGISTRY" ]; then
+    echo "当前已经是官方源，不需要切换。"
+else
+    echo "当前仓库源为: $CUSTOM_REGISTRY"
+    echo "正在切换为官方源: $NPM_OFFICIAL_REGISTRY"
+    npm config set registry $NPM_OFFICIAL_REGISTRY
+fi
+
+# 验证是否成功切换到官方源
+CURRENT_REGISTRY=$(npm config get registry)
+if [ "$CURRENT_REGISTRY" = "$NPM_OFFICIAL_REGISTRY" ]; then
+    echo "仓库源已成功切换为官方源。"
+else
+    echo "切换仓库源失败，请检查。"
+    exit 1
+fi
+
+# 登录 npm 账户
+echo "开始登录 npm，请根据提示输入用户名、密码和邮箱地址。"
+npm login
+if [ $? -ne 0 ]; then
+    echo "npm 登录失败，请检查用户名、密码和邮箱是否正确。"
+    exit 1
+fi
+
+# 执行 yarn publish 或 npm publish
+echo "请选择使用 yarn 还是 npm 发布包（输入 y 表示使用 yarn，输入 n 表示使用 npm）："
+read -p "[y/n]: " CHOICE
+
+if [ "$CHOICE" = "y" ]; then
+    yarn publish
+elif [ "$CHOICE" = "n" ]; then
+    npm publish
+else
+    echo "无效输入，请重新运行脚本并选择 y 或 n。"
+    exit 1
+fi
+
+if [ $? -ne 0 ]; then
+    echo "发布失败，请检查日志。"
+    exit 1
+else
+    echo "发布成功！"
+fi
+
+# 恢复原始仓库源
+if [ "$CUSTOM_REGISTRY" != "$NPM_OFFICIAL_REGISTRY" ]; then
+    echo "正在恢复原始仓库源: $CUSTOM_REGISTRY"
+    npm config set registry $CUSTOM_REGISTRY
+    echo "仓库源已恢复为: $(npm config get registry)"
+else
+    echo "仓库源保持为官方源，无需恢复。"
+fi
+
+echo "脚本执行完成。"

package/package.json

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

package/templates/cron.go.ejs

@@ -1,16 +1,17 @@
 package cron
 
 import (
+	"context"
 	"fmt"
 	"github.com/jom-io/gorig/cronx"
 	"github.com/jom-io/gorig/utils/logger"
 	"time"
 )
 
-func test() {
-	logger.Info(nil, fmt.Sprintf("hello, now is %s", time.Now().Format("2006-01-02 15:04:05")))
+func test(ctx context.Context) {
+	logger.Info(ctx, fmt.Sprintf("hello, now is %s", time.Now().Format("2006-01-02 15:04:05")))
 }
 
 func init() {
-	cronx.AddTask("*/10 * * * * *", test)
+	cronx.AddCronTask("*/10 * * * * *", test, 0)
 }

package/templates/init.go.ejs

@@ -2,6 +2,7 @@ package domain
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/jom-io/gorig/apix/response"
 	"github.com/jom-io/gorig/httpx"
 	"github.com/jom-io/gorig/serv"
 	configure "github.com/jom-io/gorig/utils/cofigure"
@@ -11,7 +12,7 @@ import (
 func init() {
 	httpx.RegisterRouter(func(groupRouter *gin.RouterGroup) {
 		groupRouter.GET("/", func(ctx *gin.Context) {
-			httpx.Success(ctx, "hello world, this is <%= projectNameUpper %> project generated by gorig-cli")
+			response.Success(ctx, "Hello world, this is <%= projectNameUpper %> project generated by gorig-cli", nil)
 		})
 	})
 	err := serv.RegisterService(

package/templates/skills/claude/gorig-backend/SKILL.md

@@ -0,0 +1,189 @@
+---
+name: gorig-backend
+description: Senior Go backend development expert for the gorig framework. Use when tasks involve implementing or reviewing gorig services, routers, controllers, services, models, domain modules, dx-based data access, API contract changes, test additions, or module documentation updates. Apply this skill when strict adherence to local gorig/news code patterns and real API behavior is required.
+---
+
+# Gorig Backend
+
+Implement backend work in gorig with strict framework conventions, deterministic workflow, and mandatory confirmation before coding.
+
+## Load Context First
+Read `references/onboarding-files.md`.
+Build a concrete mental model from local code before proposing changes.
+Treat code behavior as the source of truth for all framework APIs and helper methods.
+State uncertainty explicitly and ask focused questions instead of guessing.
+
+## Confirm Change Plan Before Coding
+Provide a concise plan and wait for explicit user confirmation before editing code.
+Include:
+- Business objective and boundary.
+- Data structures and persistence impact.
+- Route list with request/response and error code shape.
+- File-level change list in `Router -> Controller -> Service -> Model/Domainx`.
+- Test and documentation update plan.
+
+Do not start implementation until confirmation is received.
+
+## Implement With Framework Rules
+Follow these hard constraints:
+- Register services with `serv.RegisterService`; start with `bootstrap.StartUp()`.
+- Register routes with `httpx.RegisterRouter`; reuse existing `httpx` middleware.
+- Add `defer apix.HandlePanic(ctx)` in controllers.
+- Parse request params with `apix.BindParams` or `apix.GetParam*`.
+- Return responses with `apix.HandleData`.
+- Keep business logic in service layer.
+- Use `utils/errors` for errors.
+- Use `utils/logger` or global logger helpers for logging.
+- Do not use `fmt.Println` for runtime logging.
+- Prefer `domainx/dx` APIs for DB operations; align usage with `test/dx_test.go`.
+- Keep names short and clear; avoid long camel-case identifiers.
+- Use snake_case for storage fields and CamelCase for model fields.
+- Keep module layout under `domain/<module>/{router.go, controller.go, service.go, model/*.go}`.
+- Put shared logic in `domain/common`.
+- When a route should bypass the built-in 429 debounce middleware, add it in `router.go` with `httpx.DebouceAw(...)` before `httpx.RegisterRouter(...)`. Example: `httpx.DebouceAw("/api/catalog/markets", "/api/catalog/agents")`.
+
+## Data Access Patterns
+
+### Model layer - minimal structure
+The model `D` struct only needs fields and `DConfig()`. Do NOT add `M` type alias or `NewM()` factory:
+```go
+// CORRECT
+type D struct {
+    AgentID string `bson:"agent_id" json:"agent_id"`
+    // ...
+}
+func (d *D) DConfig() (domainx.ConType, string, string) {
+    return domainx.Mongo, global.QuantSageDB, Table
+}
+
+// WRONG - do not add these
+type M = domainx.Complex[D]
+func NewM() *M { return domainx.UseComplex[D](...) }
+```
+
+### Index registration - always in service.go init()
+Indexes are registered in `service.go` via `domainx.AutoMigrate`, never in the model file.
+Fields are automatically prefixed with `data.` by the framework - pass bare field names:
+```go
+func init() {
+    domainx.AutoMigrate(
+        func() domainx.ConTable { return domainx.UseComplex[model.D](domainx.Mongo, global.DB, model.Table) },
+        domainx.CtIdx(domainx.Idx, "field_a", "field_b", "field_c"), // compound index
+        domainx.CtIdx(domainx.Unique, "unique_field"),               // unique index
+    )
+}
+```
+
+### dx query API
+```go
+// Find multiple records
+result, err := dx.On[model.D](ctx).
+    Eq("agent_id", agentID).
+    Gte("date", startDate).
+    Sort("id", true).   // true=desc, false=asc
+    Find()              // returns domainx.ComplexList[D] = []*domainx.Complex[D]
+if err != nil { return nil, err }
+for i := range result {
+    if result[i] != nil && result[i].Data != nil {
+        // use result[i].Data
+    }
+}
+
+// Get single record
+item, err := dx.On[model.D](ctx).Eq("agent_id", agentID).Sort("id", true).Get()
+
+// Save (create or update)
+_, err := dx.On[model.D](ctx, &d).Save()
+
+// Update single field
+err := dx.On[model.D](ctx).WithID(id).Update("field", value)
+```
+
+## Execution Strategy
+
+For small changes (< ~20 lines, 1-2 files): implement directly.
+
+For larger or pattern-repeatable changes (3+ files, bulk updates): delegate only when it helps the agent move work in parallel.
+- Keep the critical path local when the next step depends on the result.
+- Give delegated workers disjoint file ownership and keep `gorig-backend` conventions in scope.
+- Verify with `go build ./...` and `go test ./...` after delegated work lands.
+
+## Maintain Documentation
+When API changes exist, create or update `doc/<module>.md` using `assets/api-doc-template.md`.
+When module behavior changes, update `domain/<module>/README.md` using `assets/module-readme-template.md`.
+
+## Go Test Convention
+
+**All tests live in `go/test/`, `package test`. Never place test files inside domain packages.**
+
+```text
+go/test/
+|-- init.go              <- Shared MongoDB init - DO NOT modify
+|-- _bin/local.yaml      <- Test DB config - DO NOT modify
+`-- {feature}_test.go    <- Add new test files here
+```
+
+`init.go` starts MongoDB before any test runs. Tests that bypass this package lose the DB connection.
+
+**New test file boilerplate:**
+
+```go
+package test
+
+import (
+    "testing"
+
+    "quantsage/domain/{module}"                       // import target domain
+    {module}model "quantsage/domain/{module}/model"   // if model types needed
+)
+
+func TestXxx_场景描述(t *testing.T) {
+    // arrange
+    input := ...
+
+    // act - only exported functions are accessible from package test
+    got := {module}.ExportedFunction(input)
+
+    // assert
+    if got != want {
+        t.Fatalf("ExportedFunction() = %v, want %v", got, want)
+    }
+}
+```
+
+**Rules:**
+- Functions under test must be **exported** (capitalized) - `package test` cannot access unexported symbols.
+- Use standard `testing` only. No testify or other assertion libraries.
+- Use `t.Fatalf` / `t.Errorf` for assertions.
+- Hardcode test data inline; do not read external files.
+
+**Run commands:**
+
+```bash
+cd go
+go test ./test/... -v              # all tests
+go test ./test/... -run TestXxx -v # single test
+```
+
+## Validate and Deliver
+Run `go build ./... && go test ./test/... -v` after every change.
+If tests cannot run, explain the exact blocker and provide a minimal verification plan.
+Deliver results in concise engineering format:
+- Change summary.
+- Key file paths.
+- Test status and suggestions.
+- Unknowns plus minimal assumptions.
+
+## Provide Database Recommendation
+When asked to choose storage, recommend based on:
+- Existing dependencies and `dx` compatibility.
+- Read/write pattern and query complexity.
+- Transaction consistency requirements.
+- Operational cost and team familiarity.
+
+Present recommendation with clear rationale and trade-offs.
+
+## Resources
+- `references/onboarding-files.md`: Required code-reading checklist for gorig and news.
+- `assets/api-doc-template.md`: API documentation template.
+- `assets/module-readme-template.md`: Module README template.

package/templates/skills/claude/gorig-backend/assets/api-doc-template.md

@@ -0,0 +1,50 @@
+# <module> API 文档
+
+## 1. 模块说明
+- 模块名：
+- 业务目标：
+- 依赖服务/存储：
+
+## 2. 接口清单
+| 名称 | 方法 | 路径 | 鉴权 | 说明 |
+| --- | --- | --- | --- | --- |
+|  |  |  |  |  |
+
+## 3. 接口详情
+
+### 3.1 <接口名>
+- 方法与路径：
+- Controller：
+- Service：
+- 说明：
+
+#### 请求参数
+| 字段 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+|  |  |  |  |
+
+#### 响应示例
+```json
+{
+  "code": 0,
+  "msg": "ok",
+  "data": {}
+}
+```
+
+#### 错误码
+| code | 含义 | 触发场景 |
+| --- | --- | --- |
+|  |  |  |
+
+## 4. 调用样例
+```bash
+curl -X POST 'http://<host>/<path>' \
+  -H 'Content-Type: application/json' \
+  -d '{}'
+```
+
+## 5. 变更记录
+| 日期 | 变更人 | 说明 |
+| --- | --- | --- |
+|  |  |  |

package/templates/skills/claude/gorig-backend/assets/module-readme-template.md

@@ -0,0 +1,46 @@
+# <module> 模块说明
+
+## 1. 模块职责
+- 目标：
+- 边界：
+- 非目标：
+
+## 2. 目录结构
+```text
+domain/<module>/
+├── router.go
+├── controller.go
+├── service.go
+└── model/
+```
+
+## 3. 请求处理流程
+1. Router 注册入口与中间件。
+2. Controller 参数处理、panic 保护、返回封装。
+3. Service 业务逻辑与错误处理。
+4. Model 或 dx 数据访问。
+
+## 4. 数据模型
+| 结构体 | 说明 | 关键字段 |
+| --- | --- | --- |
+|  |  |  |
+
+## 5. 对外接口
+| 名称 | 方法 | 路径 | 说明 |
+| --- | --- | --- | --- |
+|  |  |  |  |
+
+## 6. 错误与日志
+- 错误定义位置：
+- 常见错误码：
+- 日志关键字段：
+
+## 7. 测试与验证
+- 单测：
+- 集成测试：
+- 手工验证步骤：
+
+## 8. 维护约定
+- 命名：
+- 兼容性：
+- 文档更新规则：

package/templates/skills/claude/gorig-backend/references/onboarding-files.md

@@ -0,0 +1,38 @@
+# Onboarding File Checklist
+
+Read these files before implementation.
+
+## gorig (target project)
+- `AGENTS.md`
+- `README.md`
+- `bootstrap/startup.go`
+- `httpx/serv.go`
+- `httpx/tool.go`
+- `apix/handle.go`
+- `apix/params.go`
+- `domainx/*`
+- `domainx/dx/*`
+- `serv/serv.go`
+- `utils/errors/*`
+- `utils/logger/*`
+- `test/dx_test.go`
+
+## news (reference project, do not modify)
+- `_cmd/api/main.go`
+- `domain/init.go`
+- `domain/**/router.go`
+- `domain/**/controller.go`
+- `domain/**/service.go`
+- `domain/**/model/*.go`
+- `test/*`
+
+## Working Paths
+- Target to modify: `/Users/doz/Desktop/project/open/gorig`
+- Reference only: `/Users/doz/Desktop/project/personal/news`
+
+## Reading Strategy
+1. Trace startup and service registration.
+2. Trace a complete request path: router -> controller -> service -> model/dx.
+3. Confirm panic handling, param binding, and response helpers in real code.
+4. Confirm error and logger usage from existing modules.
+5. Reuse existing patterns before introducing new abstractions.