gorig-cli 1.0.23 → 1.0.25

package/README.md

@@ -1,6 +1,17 @@
 # Gorig CLI
 
-Gorig CLI is a scaffolding tool based on Node.js, used for quickly creating the project structure and modules based on the Gorig framework for Go.
+Gorig CLI is the command-line tool for initializing Gorig projects, generating modules, installing the `gorig-backend` skill, and keeping generated projects aligned with the verified Gorig backend roadmap.
+
+## Roadmap Status
+
+The `gorig-backend` skill roadmap is tracked in [docs/gorig-backend-skill-roadmap.md](docs/gorig-backend-skill-roadmap.md). This README documents the stable CLI workflows and the currently verified skill surface.
+
+| Scope | Status |
+|---|---|
+| Skill foundation, source rules, and version detection | verified |
+| Locally runnable basic project generation | verified |
+| HTTP API, modules, database, cache, cron, messaging, SSE, auth, security, and outbound networking guidance | verified |
+| Observability, deployment, and operations guidance | pending |
 
 ## Installation
 
@@ -18,23 +29,42 @@ npx gorig-cli@latest <command>
 
 ## Quick Start
 
-### Initialize a New Project
+### Initialize a Runnable Project
 
 Use the `init` command to create a new project:
 
 ```sh
-gorig-cli init my-new-project
+gorig-cli init my-new-project --gorig-version v0.0.52 --no-start
 ```
 
 Or use npx:
 
 ```sh
-npx gorig-cli@latest init my-new-project
+npx gorig-cli@latest init my-new-project --gorig-version v0.0.52 --no-start
+```
+
+This creates a locally runnable project with `local`, `dev`, and `prod` configuration, one `_cmd` entry point, and a Router-Controller-Service example under `domain/hello`. The basic project does not require MySQL, MongoDB, or Redis.
+
+Useful automation options:
+
+```sh
+# Use a custom Go module and base port
+gorig-cli init my-new-project \
+  --module example.com/my-new-project \
+  --gorig-version v0.0.52 \
+  --port 9527 \
+  --no-start
+
+# Framework development against a local Gorig checkout
+gorig-cli init my-new-project \
+  --gorig-replace ../gorig \
+  --no-start \
+  --no-git
 ```
 
-This will create a new project in the current directory, including basic files and directories like `_cmd/main.go`, `domain/init.go`, `cron/cron.go`, etc.
+Use `--force` only when an existing non-empty destination may be replaced. Use `--start` to start immediately; otherwise initialization is non-interactive and does not start the service.
 
-### Create a New Module
+### Create a Basic Module
 
 Use the `create` command in the project root directory to create a new module:
 
@@ -48,7 +78,38 @@ Or use npx:
 npx gorig-cli@latest create user
 ```
 
-This will create a module named `user` in the project, including folders like `api/`, `internal/`, `model/`, and necessary code.
+This creates a flat feature-first module under `domain/user`, using the Gorig Router -> Controller -> Service shape without adding database or Redis requirements:
+
+```text
+domain/user/
+├── router.go
+├── controller.go
+├── service.go
+├── dto.go
+└── model/
+    └── user.go
+```
+
+The generated routes are `GET /user/info` and `POST /user/echo`. More complex persistence-backed CRUD modules should keep the same flat module boundary and add `domainx/dx` access in `service.go` plus storage structs under `model/`.
+
+### Create a Persistent CRUD Module
+
+To generate a persistent CRUD module backed by Gorig `domainx/dx`, choose MySQL or MongoDB explicitly:
+
+```sh
+# MySQL CRUD module, with HTTP routes enabled by default
+gorig-cli create order --crud --db mysql --db-name Main
+
+# MongoDB CRUD module
+gorig-cli create order --crud --db mongo --db-name main
+
+# Service/model CRUD only, without router/controller/doc HTTP adapter
+gorig-cli create order --crud --db mysql --no-http
+```
+
+Persistent CRUD generation currently supports MySQL and MongoDB. The generated code compiles without a live database, but effect-level create/list/page/update/delete verification requires a matching development database configuration.
+
+The CRUD generator preserves existing named connections and adds non-secret configuration skeletons to `_bin/local.yaml`, `_bin/dev.yaml`, `_bin/prod.yaml`, and `test/_bin/local.yaml`. After filling local values or exporting the documented `GORIG_...` variables, run `go test -tags=integration,mysql ./test/... -v` or `go test -tags=integration,mongo ./test/... -v`.
 
 ### Generate API Documentation
 
@@ -74,29 +135,42 @@ 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:
+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 the Codex skill globally:
 
-# Install only the Codex skill
+```sh
 gorig-cli skill install codex
+```
 
-# Install Claude user-level skill
-gorig-cli skill install claude user
+Install both Codex and Claude skills globally:
 
-# Install Claude project-level skill into the current repository
-gorig-cli skill install claude project
+```sh
+gorig-cli skill install all
 ```
 
-Or use npx:
+Install the Codex skill into the current repository:
 
 ```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
+gorig-cli skill install codex project
+```
+
+The install scope defaults to `user`. Use `project` only when the skill should be stored in the current repository.
+
+### Use with AI Agents
+
+After installing the skill, open a Gorig project in Codex or Claude and ask for framework-specific backend work:
+
+```text
+Use the gorig-backend skill to add a MySQL order CRUD module with tests and API docs.
+```
+
+```text
+Use the gorig-backend skill to review startup, routing, config, and middleware usage.
+```
+
+```text
+Use the gorig-backend skill to add login, protected routes, logout, and security tests.
 ```
 
 ### Run the Project
@@ -105,7 +179,7 @@ After entering the project directory, you can run the project using the followin
 
 ```sh
 cd my-new-project
-go run _cmd/main.go
+GORIG_SYS_MODE=local go run ./_cmd
 ```
 
 Or run it after building:
@@ -113,3 +187,19 @@ Or run it after building:
 ```sh
 go build -o my-new-project _cmd/main.go && ./my-new-project
 ```
+
+## Verified Capabilities
+
+- Dependency-free project bootstrap with `local`, `dev`, and `prod` configuration.
+- Flat feature-first module generation under `domain/<module>/`.
+- MySQL and MongoDB CRUD generation through Gorig `domainx/dx`.
+- API documentation generation for generated HTTP modules.
+- Skill installation for Codex and Claude from one canonical bundled source.
+- Skill references and fixtures for cache, scheduled tasks, messaging, SSE, authentication, security, and outbound networking.
+
+## Current Boundaries
+
+- Persistent CRUD generation is verified for MySQL and MongoDB.
+- Runtime verification for MySQL, MongoDB, and Redis requires configured development infrastructure.
+- Observability, deployment, and operations guidance is the next roadmap phase.
+- Real remote deployment or production mutation requires explicit user authorization.

package/commands/create.js

@@ -8,6 +8,88 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+const readOptionValue = (args, index, name) => {
+  const arg = args[index];
+  const prefix = `${name}=`;
+  if (arg.startsWith(prefix)) {
+    return { value: arg.slice(prefix.length), nextIndex: index };
+  }
+  if (index + 1 >= args.length || args[index + 1].startsWith('--')) {
+    throw new Error(`Missing value for ${name}`);
+  }
+  return { value: args[index + 1], nextIndex: index + 1 };
+};
+
+const toModuleName = (moduleName) => moduleName
+  .split('_')
+  .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+  .join('');
+
+export const parseCreateArgs = (args) => {
+  if (args.length < 1) {
+    throw new Error('Please use the correct command format: gorig-cli create <module name>');
+  }
+
+  const moduleName = args[0];
+  if (!/^[a-z][a-z0-9_]*$/.test(moduleName)) {
+    throw new Error('Module name must use lower snake_case, for example: user or supply_order');
+  }
+
+  const options = {
+    moduleName,
+    ModuleName: toModuleName(moduleName),
+    crud: false,
+    db: '',
+    dbName: '',
+    http: true,
+  };
+
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--crud') {
+      options.crud = true;
+      continue;
+    }
+    if (arg === '--no-http') {
+      options.http = false;
+      continue;
+    }
+
+    const valueOptions = ['--db', '--database', '--store', '--db-name'];
+    const optionName = valueOptions.find((name) => arg === name || arg.startsWith(`${name}=`));
+    if (!optionName) {
+      throw new Error(`Unknown create option: ${arg}`);
+    }
+
+    const { value, nextIndex } = readOptionValue(args, i, optionName);
+    i = nextIndex;
+
+    if (['--db', '--database', '--store'].includes(optionName)) {
+      options.crud = true;
+      options.db = value.toLowerCase();
+    } else if (optionName === '--db-name') {
+      options.dbName = value;
+    }
+  }
+
+  if (options.crud) {
+    if (!['mysql', 'mongo', 'mongodb'].includes(options.db)) {
+      throw new Error('Persistent CRUD modules require --db mysql or --db mongo');
+    }
+    if (options.db === 'mongodb') {
+      options.db = 'mongo';
+    }
+    if (!options.dbName) {
+      options.dbName = options.db === 'mysql' ? 'Main' : 'main';
+    }
+    if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(options.dbName)) {
+      throw new Error('Database connection name must start with a letter and contain only letters, numbers, or underscores');
+    }
+  }
+
+  return options;
+};
+
 // Get the module name from the go.mod file
 const getGoModModuleName = async () => {
   try {
@@ -25,135 +107,208 @@ const getGoModModuleName = async () => {
   }
 };
 
-// Create module main function
-const createModule = async (args) => {
-  if (args.length < 1) {
-    console.error(chalk.yellow('Please use the correct command format: npx <your package name> create <module name>'));
-    process.exit(1);
+const renderTemplate = async (templateName, destination, data) => {
+  const templatePath = path.join(__dirname, '../templates', templateName);
+  const content = await ejs.renderFile(templatePath, data);
+  await fs.ensureDir(path.dirname(destination));
+  await fs.writeFile(destination, content);
+};
+
+const renderTemplateContent = async (templateName, data) => {
+  const templatePath = path.join(__dirname, '../templates', templateName);
+  return ejs.renderFile(templatePath, data);
+};
+
+const insertYamlConnection = (content, topKey, connectionName, connectionBlock) => {
+  const normalized = content.endsWith('\n') ? content : `${content}\n`;
+  const lines = normalized.split('\n');
+  const topIndex = lines.findIndex((line) => line === `${topKey}:`);
+
+  if (topIndex < 0) {
+    return `${normalized.trimEnd()}\n\n${topKey}:\n${connectionBlock.trimEnd()}\n`;
   }
 
-  const moduleName = args[0];
-  const ModuleName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+  let endIndex = lines.length - 1;
+  for (let i = topIndex + 1; i < lines.length; i += 1) {
+    if (/^[A-Za-z0-9_.-]+\s*:/.test(lines[i])) {
+      endIndex = i;
+      break;
+    }
+  }
 
-  // Get the current working directory, which is the directory where the command is executed
-  const currentDir = process.cwd();
+  const connectionPattern = new RegExp(`^  ${connectionName}:\\s*$`);
+  if (lines.slice(topIndex + 1, endIndex).some((line) => connectionPattern.test(line))) {
+    return content;
+  }
 
-  // Build the paths for the domain directory and module directory
-  const domainDir = path.join(currentDir, 'domain');
-  const moduleDir = path.join(domainDir, moduleName);
+  lines.splice(endIndex, 0, ...connectionBlock.trimEnd().split('\n'));
+  return `${lines.join('\n').trimEnd()}\n`;
+};
 
-  // Define the subdirectories to be created
-  const subDirs = ['api', 'model', 'internal', 'api/req'];
+const ensureCrudConfig = async (projectDir, data) => {
+  const topKey = data.db === 'mysql' ? 'Mysql' : 'mongo';
+  const templateName = data.db === 'mysql'
+    ? 'crud.mysql.config.yaml.ejs'
+    : 'crud.mongo.config.yaml.ejs';
+  const connectionBlock = await renderTemplateContent(templateName, data);
+  const configPaths = [
+    '_bin/local.yaml',
+    '_bin/dev.yaml',
+    '_bin/prod.yaml',
+    'test/_bin/local.yaml',
+  ];
 
-  console.log(chalk.blue(`\nStarting to create module: ${chalk.bold(moduleName)}`));
+  for (const relativePath of configPaths) {
+    const configPath = path.join(projectDir, relativePath);
+    if (!await fs.pathExists(configPath)) {
+      console.log(chalk.yellow(`Could not find ${relativePath}, skipping database configuration`));
+      continue;
+    }
 
-  try {
-    const projectName = await getGoModModuleName();
+    const original = await fs.readFile(configPath, 'utf8');
+    const updated = insertYamlConnection(original, topKey, data.dbName, connectionBlock);
+    if (updated !== original) {
+      await fs.writeFile(configPath, updated);
+      console.log(chalk.green(`Successfully updated ${chalk.bold(relativePath)} database configuration`));
+    }
+  }
+};
 
-    await fs.ensureDir(domainDir);
-    await fs.ensureDir(moduleDir);
-
-    // Create subdirectories
-    const createSubDirs = subDirs.map((subDir) => {
-      const subDirPath = path.join(moduleDir, subDir);
-      return fs.ensureDir(subDirPath);
-    });
-    await Promise.all(createSubDirs);
-
-    // Create and write model.go file
-    const modelDir = path.join(moduleDir, 'model');
-    const modelFilePath = path.join(modelDir, `${moduleName}.go`);
-    const modelTemplatePath = path.join(__dirname, '../templates/model.go.ejs');
-    const modelContent = await ejs.renderFile(modelTemplatePath, { moduleName, ModuleName, projectName });
-    await fs.writeFile(modelFilePath, modelContent);
-    console.log(chalk.green(`Successfully created ${chalk.bold('model.go')} file`));
-
-    // Create and write req.go file
-    const apiDir = path.join(moduleDir, 'api');
-    const reqDir = path.join(apiDir, 'req');
-    const reqFilePath = path.join(reqDir, `req.go`);
-    const reqTemplatePath = path.join(__dirname, '../templates/req.go.ejs');
-    const reqContent = await ejs.renderFile(reqTemplatePath, { moduleName, ModuleName, projectName });
-    await fs.writeFile(reqFilePath, reqContent);
-    console.log(chalk.green(`Successfully created ${chalk.bold('req.go')} file`));
-
-    // Create and write resp.go file
-    const respFilePath = path.join(reqDir, `resp.go`);
-    const respTemplatePath = path.join(__dirname, '../templates/resp.go.ejs');
-    const respContent = await ejs.renderFile(respTemplatePath, { moduleName, ModuleName, projectName });
-    await fs.writeFile(respFilePath, respContent);
-    console.log(chalk.green(`Successfully created ${chalk.bold('resp.go')} file`));
-
-    // Create and write internal.go file
-    const internalDir = path.join(moduleDir, 'internal');
-    const internalFilePath = path.join(internalDir, `${moduleName}.go`);
-    const internalTemplatePath = path.join(__dirname, '../templates/internal.go.ejs');
-    const internalContent = await ejs.renderFile(internalTemplatePath, { moduleName, ModuleName, projectName });
-    await fs.writeFile(internalFilePath, internalContent);
-    console.log(chalk.green(`Successfully created ${chalk.bold('internal.go')} file`));
-
-    // Create and write service.pub.go file
-    const serviceFilePath = path.join(apiDir, `service.pub.go`);
-    const serviceTemplatePath = path.join(__dirname, '../templates/service.pub.go.ejs');
-    const serviceContent = await ejs.renderFile(serviceTemplatePath, { moduleName, ModuleName, projectName });
-    await fs.writeFile(serviceFilePath, serviceContent);
-    console.log(chalk.green(`Successfully created ${chalk.bold('service.pub.go')} file`));
-
-    // Create and write service.go file
-    const serviceGoFilePath = path.join(apiDir, `service.go`);
-    const serviceGoTemplatePath = path.join(__dirname, '../templates/service.go.ejs');
-    const serviceGoContent = await ejs.renderFile(serviceGoTemplatePath, { moduleName, ModuleName, projectName });
-    await fs.writeFile(serviceGoFilePath, serviceGoContent);
-    console.log(chalk.green(`Successfully created ${chalk.bold('service.go')} file`));
-
-    // Create and write controller.go file
-    const controllerGoFilePath = path.join(apiDir, `controller.go`);
-    const controllerGoTemplatePath = path.join(__dirname, '../templates/controller.go.ejs');
-    const controllerGoContent = await ejs.renderFile(controllerGoTemplatePath, { moduleName, ModuleName, projectName });
-    await fs.writeFile(controllerGoFilePath, controllerGoContent);
+const updateDomainInit = async (domainDir, projectName, moduleName) => {
+  const initFilePath = path.join(domainDir, 'init.go');
+  if (!await fs.pathExists(initFilePath)) {
+    console.log(chalk.yellow(`Could not find ${chalk.bold('init.go')} file, skipping import statement addition`));
+    return;
+  }
+
+  let initFileContent = await fs.readFile(initFilePath, 'utf-8');
+  const importStatement = `import _ "${projectName}/domain/${moduleName}"`;
+
+  if (initFileContent.includes(importStatement)) {
+    console.log(chalk.yellow('The corresponding import statement already exists in init.go, no need to add it again'));
+    return;
+  }
+
+  const packageMatch = initFileContent.match(/^package\s+\w+\s*$/m);
+  if (!packageMatch) {
+    console.log(chalk.yellow('package declaration not found, skipping import statement addition'));
+    return;
+  }
+
+  const insertPosition = packageMatch.index + packageMatch[0].length;
+  const rest = initFileContent.slice(insertPosition).trimStart();
+  initFileContent =
+    `${initFileContent.slice(0, insertPosition).trimEnd()}\n\n` +
+    `${importStatement}\n` +
+    (rest ? `\n${rest}` : '');
+
+  await fs.writeFile(initFilePath, initFileContent);
+  console.log(chalk.green(`Successfully updated ${chalk.bold('init.go')} file, added import statement`));
+};
+
+const createSimpleModule = async (moduleDir, data) => {
+  const { moduleName } = data;
+
+  await renderTemplate('model.go.ejs', path.join(moduleDir, 'model', `${moduleName}.go`), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('model.go')} file`));
+
+  await renderTemplate('dto.go.ejs', path.join(moduleDir, 'dto.go'), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('dto.go')} file`));
+
+  await renderTemplate('service.go.ejs', path.join(moduleDir, 'service.go'), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('service.go')} file`));
+
+  await renderTemplate('controller.go.ejs', path.join(moduleDir, 'controller.go'), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('controller.go')} file`));
+
+  await renderTemplate('router.go.ejs', path.join(moduleDir, 'router.go'), data);
+  console.log(chalk.green(`Successfully created ${chalk.bold('router.go')} file`));
+};
+
+const createCrudModule = async (moduleDir, projectDir, data, options) => {
+  const { moduleName } = data;
+  const crudData = {
+    ...data,
+    ...options,
+    dbTitle: options.db === 'mysql' ? 'MySQL' : 'MongoDB',
+    dbEnvName: options.dbName.replace(/[^A-Za-z0-9]/g, '_').toUpperCase(),
+    dbSchema: path.basename(projectDir).replace(/[^a-z0-9]/gi, '_').toLowerCase(),
+  };
+
+  await ensureCrudConfig(projectDir, crudData);
+
+  await renderTemplate('crud.model.go.ejs', path.join(moduleDir, 'model', `${moduleName}.go`), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('model.go')} file`));
+
+  await renderTemplate('crud.dto.go.ejs', path.join(moduleDir, 'dto.go'), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('dto.go')} file`));
+
+  await renderTemplate('crud.service.go.ejs', path.join(moduleDir, 'service.go'), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('service.go')} file`));
+
+  await renderTemplate('crud.module.README.md.ejs', path.join(moduleDir, 'README.md'), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('README.md')} file`));
+
+  await renderTemplate('crud.test.go.ejs', path.join(projectDir, 'test', `${moduleName}_test.go`), crudData);
+  console.log(chalk.green(`Successfully created ${chalk.bold('test file')} file`));
+
+  const integrationInitPath = path.join(projectDir, 'test', `init_${options.db}_integration_test.go`);
+  if (!await fs.pathExists(integrationInitPath)) {
+    await renderTemplate('crud.integration.init_test.go.ejs', integrationInitPath, crudData);
+    console.log(chalk.green(`Successfully created ${chalk.bold('database integration init file')} file`));
+  }
+
+  await renderTemplate(
+    'crud.integration_test.go.ejs',
+    path.join(projectDir, 'test', `${moduleName}_integration_test.go`),
+    crudData,
+  );
+  console.log(chalk.green(`Successfully created ${chalk.bold('database integration test file')} file`));
+
+  if (options.http) {
+    await renderTemplate('crud.controller.go.ejs', path.join(moduleDir, 'controller.go'), crudData);
     console.log(chalk.green(`Successfully created ${chalk.bold('controller.go')} file`));
 
-    // Create and write router.go file
-    const routerGoFilePath = path.join(apiDir, `router.go`);
-    const routerGoTemplatePath = path.join(__dirname, '../templates/router.go.ejs');
-    const routerGoContent = await ejs.renderFile(routerGoTemplatePath, { moduleName, ModuleName, projectName });
-    await fs.writeFile(routerGoFilePath, routerGoContent);
+    await renderTemplate('crud.router.go.ejs', path.join(moduleDir, 'router.go'), crudData);
     console.log(chalk.green(`Successfully created ${chalk.bold('router.go')} file`));
 
-    // Check and update domain/init.go file
-    const initFilePath = path.join(domainDir, 'init.go');
-    if (await fs.pathExists(initFilePath)) {
-      let initFileContent = await fs.readFile(initFilePath, 'utf-8');
-
-      const importStatement = `import _ "${projectName}/domain/${moduleName}/api"`;
-
-      if (!initFileContent.includes(importStatement)) {
-        const initFuncIndex = initFileContent.indexOf('func init()');
-
-        if (initFuncIndex !== -1) {
-          // Find init function, ensure import statement is added above init function
-          const insertPosition = initFuncIndex;
-          const headCode = initFileContent.slice(0, insertPosition).trimEnd();
-          initFileContent =
-            `${headCode}\n` +
-            `${importStatement}\n\n` +
-            initFileContent.slice(insertPosition);
-
-          await fs.writeFile(initFilePath, initFileContent);
-          console.log(chalk.green(`Successfully updated ${chalk.bold('init.go')} file, added import statement`));
-        } else {
-          console.log(chalk.yellow(`init() function not found, skipping import statement addition`));
-        }
-      } else {
-        console.log(chalk.yellow(`The corresponding import statement already exists in init.go, no need to add it again`));
-      }
+    await renderTemplate('crud.doc.md.ejs', path.join(projectDir, 'doc', `${moduleName}.md`), crudData);
+    console.log(chalk.green(`Successfully created ${chalk.bold('doc file')} file`));
+  }
+};
+
+// Create module main function
+const createModule = async (args) => {
+  try {
+    const options = parseCreateArgs(args);
+    const { moduleName, ModuleName } = options;
+    const currentDir = process.cwd();
+    const domainDir = path.join(currentDir, 'domain');
+    const moduleDir = path.join(domainDir, moduleName);
+
+    console.log(chalk.blue(`\nStarting to create module: ${chalk.bold(moduleName)}`));
+
+    const projectName = await getGoModModuleName();
+    const data = { moduleName, ModuleName, projectName };
+
+    await fs.ensureDir(domainDir);
+    await fs.ensureDir(path.join(moduleDir, 'model'));
+
+    if (options.crud) {
+      await createCrudModule(moduleDir, currentDir, data, options);
     } else {
-      console.log(chalk.yellow(`Could not find ${chalk.bold('init.go')} file, skipping import statement addition`));
+      await createSimpleModule(moduleDir, data);
+    }
+
+    if (!options.crud || options.http) {
+      await updateDomainInit(domainDir, projectName, moduleName);
     }
 
-    console.log(chalk.blue(`\nModule ${chalk.bold(moduleName)} has been successfully created in ${chalk.bold(`domain/${moduleName}`)} directory`));
+    const profile = options.crud ? `persistent CRUD (${options.db})` : 'basic';
+    console.log(chalk.blue(`\nModule ${chalk.bold(moduleName)} has been successfully created in ${chalk.bold(`domain/${moduleName}`)} directory [${profile}]`));
   } catch (error) {
     console.error(chalk.red('Error creating module:'), chalk.redBright(error.message));
+    process.exitCode = 1;
   }
 };
 

package/commands/doc.js

@@ -422,16 +422,27 @@ const generateOpenAPIDocs = async (moduleName = null) => {
 
         for (const module of modulesToProcess) {
             const modulePath = path.join(domainDir, module);
-            const routerFilePath = path.join(modulePath, 'api/router.go');
-            const controllerFilePath = path.join(modulePath, 'api/controller.go');
+            const flatRouterFilePath = path.join(modulePath, 'router.go');
+            const flatControllerFilePath = path.join(modulePath, 'controller.go');
+            const legacyRouterFilePath = path.join(modulePath, 'api/router.go');
+            const legacyControllerFilePath = path.join(modulePath, 'api/controller.go');
+            const routerFilePath = await fs.pathExists(flatRouterFilePath) ? flatRouterFilePath : legacyRouterFilePath;
+            const controllerFilePath = await fs.pathExists(flatControllerFilePath) ? flatControllerFilePath : legacyControllerFilePath;
             const modelFilePath = path.join(modulePath, 'model', `${module}.go`);
+            const dtoFilePath = path.join(modulePath, 'dto.go');
             const reqFilePath = path.join(modulePath, 'api', 'req', 'req.go');
 
             // 检查文件是否存在
-            if (!(await fs.pathExists(routerFilePath)) || !(await fs.pathExists(controllerFilePath)) || !(await fs.pathExists(modelFilePath)) || !(await fs.pathExists(reqFilePath))) {
+            if (!(await fs.pathExists(routerFilePath)) || !(await fs.pathExists(controllerFilePath)) || !(await fs.pathExists(modelFilePath))) {
                 console.warn(chalk.yellow(`Module "${module}" is missing required files, skipping...`));
                 continue;
             }
+            const schemaFilePaths = [modelFilePath];
+            if (await fs.pathExists(dtoFilePath)) {
+                schemaFilePaths.push(dtoFilePath);
+            } else if (await fs.pathExists(reqFilePath)) {
+                schemaFilePaths.push(reqFilePath);
+            }
 
             // 扫描 router.go 获取路由信息
             const routes = await scanRouterFile(routerFilePath);
@@ -439,13 +450,15 @@ const generateOpenAPIDocs = async (moduleName = null) => {
 
             // 扫描 controller.go 获取方法参数
             const controllerContent = await fs.readFile(controllerFilePath, 'utf-8');
-            const controllerParams = await extractParamsFromController(controllerContent, path.dirname(reqFilePath), path.dirname(modelFilePath));
+            const reqDir = await fs.pathExists(reqFilePath) ? path.dirname(reqFilePath) : modulePath;
+            const controllerParams = await extractParamsFromController(controllerContent, reqDir, path.dirname(modelFilePath));
             // console.log(`Extracted controller parameters for module "${module}":`, controllerParams);
 
-            // 扫描 model.go 和 req.go 获取字段
-            const modelFields = await extractModelFields(modelFilePath);
-            const reqFields = await extractModelFields(reqFilePath);
-            const allFields = [...modelFields, ...reqFields];
+            // 扫描 model.go 和 dto.go/req.go 获取字段
+            const allFields = [];
+            for (const schemaFilePath of schemaFilePaths) {
+                allFields.push(...await extractModelFields(schemaFilePath));
+            }
 
             // 生成 OpenAPI 格式文档
             const openAPIDoc = {