nuxt-gin-tools 0.2.21 → 0.2.23

package/README.md

@@ -24,6 +24,8 @@ Quick Jump:
 - 🧩 `pack.config.ts` support with typed config helper
 - 🛡️ Config validation with `warn` and `error` feedback
 - 🔧 Useful CLI switches for partial workflows like `--skip-go`
+- 🎨 Colorful command banners and clearer terminal feedback
+- 📋 Fancy end-of-command summaries that show what just changed
 
 ### 📦 Install
 
@@ -31,6 +33,12 @@ Quick Jump:
 pnpm add -D nuxt-gin-tools
 ```
 
+or
+
+```bash
+bun add -d nuxt-gin-tools
+```
+
 ### ⚡ Quick Start
 
 ```bash
@@ -62,6 +70,7 @@ Runs the local development stack:
 
 - Nuxt: `npx nuxt dev --port=<nuxtPort> --host`
 - Go: watches files and restarts `go run main.go`
+- prints a styled command banner before startup
 
 Flags:
 
@@ -75,41 +84,65 @@ Bootstraps the project:
 
 - always runs `npx nuxt prepare`
 - if Go is available, also runs `go mod download && go mod tidy`
+- prints a styled command banner before execution
 
-#### `nuxt-gin gen`
-
-Generates API code from `openapi.yaml`:
+Options:
 
-- Go Gin server code
-- TypeScript axios client code
+- `--skip-go`: skip Go dependency bootstrap
+- `--skip-nuxt`: skip Nuxt prepare
 
 #### `nuxt-gin build`
 
 Runs the build-and-pack flow.
 
+Terminal output includes:
+
+- a styled command banner at startup
+- the final `.7z` archive path after packing
+- the bundle directory path used to assemble the release
+
 Flags:
 
 - `--skip-go`: skip Go build
 - `--skip-nuxt`: skip Nuxt static build
+- `--skip-build`: skip the build step and only assemble/package existing artifacts
+- `--skip-zip`: skip `.7z` creation and only prepare the bundle directory
 - `--binary-name <name>`: override the Go binary name under `.build/.server`
 
 #### `nuxt-gin cleanup`
 
 Removes generated temp files and build output.
 
+Also prints a styled command banner before cleanup starts.
+
+Options:
+
+- `--dry-run`: print what would be removed without deleting anything
+
 #### `nuxt-gin update`
 
 Updates project dependencies with a conservative default strategy:
 
-- Node: `pnpm update`
+- Node: package manager is controlled by `--package-manager`, default `auto`
 - Go: `go get -u=patch ./... && go mod tidy`
 
-Flags:
+Options:
 
-- `--latest`: switch to a more aggressive upgrade strategy
+- `--package-manager <auto|bun|pnpm|npm>`: package manager selection, default `auto`
+- `--latest <true|false>`: whether to use the aggressive update strategy, default `false`
 - `--skip-go`: skip Go dependency updates
 - `--skip-node`: skip Node dependency updates
 
+Examples:
+
+```bash
+nuxt-gin update
+nuxt-gin update --package-manager bun --latest true
+nuxt-gin update --package-manager pnpm --latest false
+```
+
+Also prints a styled command banner before execution.
+
 ### 🧩 `pack.config.ts` / `pack.config.json`
 
 `nuxt-gin build` can auto-load pack config from the project root with this priority:
@@ -233,15 +266,18 @@ NUXT_GIN_WATCH_CONFIG=/path/to/.go-watch.json
 ### 🖥️ Environment
 
 - Node.js
-- pnpm
+- pnpm or bun
 - Go, if you need the Gin side to run
-- `openapi-generator-cli`, only for `nuxt-gin gen`
+- no extra generator dependency is required for the current command set
 
 ### 📝 Notes
 
 - 💨 Go hot reload no longer depends on Air
 - 👀 The current watcher model is `chokidar` + restart `go run main.go`
 - 🪟 Packaging uses platform-aware executable naming: Windows defaults to `.exe`, Linux/macOS defaults to no extension
+- 🌈 Main commands print a consistent banner and clearer success/info output in the terminal
+- 📋 Commands also print a styled summary of the actions they performed; long-running dev commands print the startup summary before entering watch mode
+- 📦 Both `pnpm` and `bun` are supported, but one working tree should stick to one package manager at a time
 
 ---
 
@@ -255,6 +291,8 @@ NUXT_GIN_WATCH_CONFIG=/path/to/.go-watch.json
 - 🧩 支持 `pack.config.ts`，并提供类型化 helper
 - 🛡️ 对打包配置做校验，区分 `warn` 和 `error`
 - 🔧 支持 `--skip-go` 等局部开发参数
+- 🎨 提供更醒目的彩色命令行 banner 与输出提示
+- 📋 命令结束时会打印更清晰的结果摘要
 
 ### 📦 安装
 
@@ -262,6 +300,12 @@ NUXT_GIN_WATCH_CONFIG=/path/to/.go-watch.json
 pnpm add -D nuxt-gin-tools
 ```
 
+或
+
+```bash
+bun add -d nuxt-gin-tools
+```
+
 ### ⚡ 快速开始
 
 ```bash
@@ -293,6 +337,7 @@ nuxt-gin dev --no-cleanup
 
 - Nuxt：`npx nuxt dev --port=<nuxtPort> --host`
 - Go：监听文件变化并重启 `go run main.go`
+- 启动前会输出一段样式化 banner
 
 参数：
 
@@ -306,41 +351,65 @@ nuxt-gin dev --no-cleanup
 
 - 总是执行 `npx nuxt prepare`
 - 检测到 Go 后，额外执行 `go mod download && go mod tidy`
+- 执行前会输出一段样式化 banner
 
-#### `nuxt-gin gen`
-
-基于 `openapi.yaml` 生成 API 代码：
+参数：
 
-- Go Gin server 代码
-- TypeScript axios 客户端代码
+- `--skip-go`：跳过 Go 依赖初始化
+- `--skip-nuxt`：跳过 Nuxt prepare
 
 #### `nuxt-gin build`
 
 执行构建与打包流程。
 
+命令行输出会额外包含：
+
+- 启动时的样式化 banner
+- 打包完成后的 `.7z` 文件绝对路径
+- 组装发布产物时使用的 bundle 目录路径
+
 参数：
 
 - `--skip-go`：跳过 Go 构建
 - `--skip-nuxt`：跳过 Nuxt 静态构建
+- `--skip-build`：跳过构建阶段，仅组装或打包现有产物
+- `--skip-zip`：跳过 `.7z` 生成，仅准备 bundle 目录
 - `--binary-name <name>`：覆盖 `.build/.server` 下的 Go 二进制名称
 
 #### `nuxt-gin cleanup`
 
 清理临时文件与构建产物。
 
+执行前也会输出一段样式化 banner。
+
+参数：
+
+- `--dry-run`：只打印将要删除的内容，不真正删除
+
 #### `nuxt-gin update`
 
 按偏保守的默认策略更新依赖：
 
-- Node：`pnpm update`
+- Node：通过 `--package-manager` 控制，默认值为 `auto`
 - Go：`go get -u=patch ./... && go mod tidy`
 
 参数：
 
-- `--latest`：切换成更激进的升级策略
+- `--package-manager <auto|bun|pnpm|npm>`：指定包管理器，默认 `auto`
+- `--latest <true|false>`：是否使用更激进的升级策略，默认 `false`
 - `--skip-go`：跳过 Go 依赖更新
 - `--skip-node`：跳过 Node 依赖更新
 
+示例：
+
+```bash
+nuxt-gin update
+nuxt-gin update --package-manager bun --latest true
+nuxt-gin update --package-manager pnpm --latest false
+```
+
+执行前也会输出一段样式化 banner。
+
 ### 🧩 `pack.config.ts` / `pack.config.json`
 
 `nuxt-gin build` 会自动读取项目根目录中的打包配置，优先级如下：
@@ -464,12 +533,15 @@ NUXT_GIN_WATCH_CONFIG=/path/to/.go-watch.json
 ### 🖥️ 环境依赖
 
 - Node.js
-- pnpm
+- pnpm 或 bun
 - Go，若需要运行 Gin 侧开发流程
-- `openapi-generator-cli`，仅 `nuxt-gin gen` 需要
+- 当前命令集不再依赖额外的代码生成器
 
 ### 📝 说明
 
 - 💨 Go 热更新不再依赖 Air
 - 👀 当前 Go 开发监听方案为 `chokidar` + 重启 `go run main.go`
 - 🪟 打包时会按平台生成可执行文件名：Windows 默认 `.exe`，Linux/macOS 默认无扩展名
+- 🌈 主要命令会输出统一风格的 banner，并提供更清晰的成功 / 信息提示
+- 📋 命令结束后会打印本次实际执行内容的摘要；`dev` 这类常驻命令会在进入监听前先打印启动摘要
+- 📦 同一个工作副本建议固定使用一种包管理器，不要在同一套依赖目录里反复混用 `pnpm` 与 `bun`

package/commands/cleanup.d.ts

@@ -1,8 +1,11 @@
-export declare function ifExistsRemove(relativePath: string): void;
-export declare function cleanUpNuxt(): Promise<import("concurrently").CloseEvent[]>;
-export declare function cleanUpBuild(): void;
+export type CleanupOptions = {
+    dryRun?: boolean;
+};
+export declare function ifExistsRemove(relativePath: string, options?: CleanupOptions, actions?: string[]): void;
+export declare function cleanUpNuxt(options?: CleanupOptions, actions?: string[]): Promise<void> | Promise<import("concurrently").CloseEvent[]>;
+export declare function cleanUpBuild(options?: CleanupOptions, actions?: string[]): void;
 /**
  * 清理构建目录和临时文件
  */
-export declare function cleanUp(): Promise<void>;
+export declare function cleanUp(options?: CleanupOptions): Promise<void>;
 export default cleanUp;

package/commands/cleanup.js

@@ -52,46 +52,58 @@ exports.cleanUp = cleanUp;
 const FS = __importStar(require("fs-extra"));
 const Path = __importStar(require("path"));
 const concurrently_1 = __importDefault(require("concurrently"));
-const chalk_1 = __importDefault(require("chalk"));
+const terminal_ui_1 = require("../src/terminal-ui");
 const cwd = process.cwd();
-function ifExistsRemove(relativePath) {
+const CLEANUP_PATHS = [
+    ".build/production",
+    "dist",
+    ".build",
+    "tmp",
+    "vue/.output",
+    ".openapi-generator",
+];
+function ifExistsRemove(relativePath, options = {}, actions = []) {
     const absolutePath = Path.resolve(cwd, relativePath);
     if (FS.existsSync(absolutePath)) {
+        if (options.dryRun) {
+            (0, terminal_ui_1.printCommandInfo)("cleanup", `would remove ${absolutePath}`);
+            actions.push(`would remove ${relativePath}`);
+            return;
+        }
         FS.removeSync(absolutePath);
+        actions.push(`removed ${relativePath}`);
     }
 }
-function cleanUpNuxt() {
+function cleanUpNuxt(options = {}, actions = []) {
+    if (options.dryRun) {
+        (0, terminal_ui_1.printCommandInfo)("cleanup", "would run `npx nuxt cleanup`");
+        actions.push("would run nuxt cleanup");
+        return Promise.resolve();
+    }
+    actions.push("ran nuxt cleanup");
     return (0, concurrently_1.default)([
         {
             command: "npx nuxt cleanup",
         },
     ]).result;
 }
-function cleanUpBuild() {
-    // 清理构建目录
-    ifExistsRemove(".build/production");
-    // 清理原始 dist 目录
-    ifExistsRemove("dist");
-    // 清理临时文件
-    ifExistsRemove(".build");
-    // 清理临时文件
-    ifExistsRemove("tmp");
-    // 清理 Vue 应用构建输出目录
-    ifExistsRemove("vue/.output");
-    // 清理 OpenAPI 生成的文件
-    ifExistsRemove(".openapi-generator");
-    // 清理go.sum
-    // ifExistsRemove("go.sum");
+function cleanUpBuild(options = {}, actions = []) {
+    for (const path of CLEANUP_PATHS) {
+        ifExistsRemove(path, options, actions);
+    }
 }
 /**
  * 清理构建目录和临时文件
  */
 function cleanUp() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = cleanUpNuxt();
-        cleanUpBuild();
+    return __awaiter(this, arguments, void 0, function* (options = {}) {
+        (0, terminal_ui_1.printCommandBanner)("cleanup", "Remove generated build output and temporary files");
+        const actions = [];
+        const result = cleanUpNuxt(options, actions);
+        cleanUpBuild(options, actions);
         yield result;
-        console.log(chalk_1.default.bgGreen("----- 清理完成！-----"));
+        (0, terminal_ui_1.printCommandSuccess)("cleanup", options.dryRun ? "Dry run completed" : "Temporary files removed");
+        (0, terminal_ui_1.printCommandSummary)("cleanup", actions);
     });
 }
 exports.default = cleanUp;

package/commands/dev-go.js

@@ -15,15 +15,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startGoDev = startGoDev;
 const child_process_1 = require("child_process");
 const chokidar_1 = __importDefault(require("chokidar"));
-const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const utils_1 = require("../src/utils");
+const terminal_ui_1 = require("../src/terminal-ui");
 const cwd = process.cwd();
 const RESTART_DEBOUNCE_MS = 150;
 const SHUTDOWN_TIMEOUT_MS = 2000;
 const LOG_TAG = "go-watch";
-const GO_WATCH_PREFIX = chalk_1.default.bgMagenta.white(`[${LOG_TAG}]`);
+const GO_WATCH_PREFIX = `[${LOG_TAG}]`;
 const serverConfigPath = (0, path_1.join)(cwd, "server.config.json");
 const ginPort = getGinPort();
 function getGinPort() {
@@ -97,7 +97,7 @@ function loadWatchConfig() {
         parsedConfig = JSON.parse((0, fs_extra_1.readFileSync)(configPath, "utf-8"));
     }
     catch (_j) {
-        console.warn(`${GO_WATCH_PREFIX} invalid watch config JSON, fallback to defaults: ${configPath}`);
+        (0, terminal_ui_1.printCommandWarn)(`${GO_WATCH_PREFIX} invalid watch config JSON, fallback to defaults: ${configPath}`);
         return defaultConfig;
     }
     const includeExt = toStringArray((_a = parsedConfig.includeExt) !== null && _a !== void 0 ? _a : parsedConfig.include_ext)
@@ -184,7 +184,7 @@ function quote(arg) {
 function runGoProcess() {
     const command = `go run ${quote("main.go")}`;
     killGinPortIfNeeded();
-    console.log(`${GO_WATCH_PREFIX} start: ${command}`);
+    (0, terminal_ui_1.printCommandLog)(GO_WATCH_PREFIX, `start: ${command}`);
     return (0, child_process_1.spawn)(command, {
         cwd,
         shell: true,
@@ -241,7 +241,7 @@ function startGoDev() {
         const watchRoots = watchConfig.includeDir.length
             ? watchConfig.includeDir.map((dir) => (0, path_1.join)(cwd, dir))
             : [cwd];
-        console.log(`${GO_WATCH_PREFIX} watching: ${watchRoots.map((item) => toProjectRelative(item)).join(", ")}`);
+        (0, terminal_ui_1.printCommandLog)(GO_WATCH_PREFIX, `watching: ${watchRoots.map((item) => toProjectRelative(item)).join(", ")}`);
         let restarting = false;
         let goProc = runGoProcess();
         let restartTimer = null;
@@ -266,7 +266,7 @@ function startGoDev() {
                     return;
                 }
                 restarting = true;
-                console.log(`${GO_WATCH_PREFIX} ${eventName}: ${relPath}, restarting...`);
+                (0, terminal_ui_1.printCommandLog)(GO_WATCH_PREFIX, `${eventName}: ${relPath}, restarting...`);
                 yield stopGoProcess(goProc);
                 goProc = runGoProcess();
                 restarting = false;
@@ -277,7 +277,7 @@ function startGoDev() {
             .on("change", (filePath) => triggerRestart("change", filePath))
             .on("unlink", (filePath) => triggerRestart("unlink", filePath))
             .on("error", (error) => {
-            console.error(`${GO_WATCH_PREFIX} watcher error: ${String(error)}`);
+            (0, terminal_ui_1.printCommandError)(`${GO_WATCH_PREFIX} watcher error`, error);
         });
         const shutdown = () => __awaiter(this, void 0, void 0, function* () {
             if (restartTimer) {
@@ -300,7 +300,7 @@ function startGoDev() {
 if (require.main === module) {
     // 兼容直接执行该文件（例如 node src/dev-go.js）。
     startGoDev().catch((error) => {
-        console.error(`${GO_WATCH_PREFIX} failed to start: ${String(error)}`);
+        (0, terminal_ui_1.printCommandError)(`${GO_WATCH_PREFIX} failed to start`, error);
         process.exit(1);
     });
 }

package/commands/develop.js

@@ -22,6 +22,7 @@ const cleanup_1 = __importDefault(require("./cleanup"));
 const postinstall_1 = __importDefault(require("./postinstall"));
 const dev_go_1 = require("./dev-go");
 const utils_1 = require("../src/utils");
+const terminal_ui_1 = require("../src/terminal-ui");
 const cwd = process.cwd();
 const serverConfig = (0, fs_extra_1.readJSONSync)((0, path_1.join)(cwd, "server.config.json"));
 function prepareDevelop() {
@@ -68,6 +69,8 @@ function runGoDev() {
  */
 function develop() {
     return __awaiter(this, arguments, void 0, function* (options = {}) {
+        (0, terminal_ui_1.printCommandBanner)("dev", "Start Nuxt and Go development workflows");
+        const actions = [];
         const killPortBeforeDevelop = serverConfig.killPortBeforeDevelop !== false;
         yield prepareDevelop(options);
         // 在开发前确保占用端口被释放
@@ -76,14 +79,24 @@ function develop() {
                 options.skipGo ? undefined : serverConfig.ginPort,
                 options.skipNuxt ? undefined : serverConfig.nuxtPort,
             ]);
+            actions.push("released occupied development ports");
         }
         const tasks = [];
         if (!options.skipGo) {
             tasks.push(runGoDev());
+            actions.push(`started Go watcher on port ${serverConfig.ginPort}`);
         }
         if (!options.skipNuxt) {
             tasks.push(runNuxtDev());
+            actions.push(`started Nuxt dev server on port ${serverConfig.nuxtPort}`);
         }
+        if (options.skipGo) {
+            actions.push("skipped Go workflow");
+        }
+        if (options.skipNuxt) {
+            actions.push("skipped Nuxt workflow");
+        }
+        (0, terminal_ui_1.printCommandSummary)("dev", actions);
         yield Promise.all(tasks);
     });
 }
@@ -94,11 +107,16 @@ function develop() {
  */
 function developNuxt() {
     return __awaiter(this, arguments, void 0, function* (options = {}) {
+        (0, terminal_ui_1.printCommandBanner)("dev:nuxt", "Start Nuxt development server only");
+        const actions = [];
         const killPortBeforeDevelop = serverConfig.killPortBeforeDevelop !== false;
         yield prepareDevelop(options);
         if (killPortBeforeDevelop) {
             (0, utils_1.killPorts)([serverConfig.nuxtPort]);
+            actions.push("released Nuxt dev port");
         }
+        actions.push(`started Nuxt dev server on port ${serverConfig.nuxtPort}`);
+        (0, terminal_ui_1.printCommandSummary)("dev:nuxt", actions);
         yield runNuxtDev();
     });
 }
@@ -109,11 +127,16 @@ function developNuxt() {
  */
 function developGo() {
     return __awaiter(this, arguments, void 0, function* (options = {}) {
+        (0, terminal_ui_1.printCommandBanner)("dev:go", "Start Go watcher only");
+        const actions = [];
         const killPortBeforeDevelop = serverConfig.killPortBeforeDevelop !== false;
         yield prepareDevelop(options);
         if (killPortBeforeDevelop) {
             (0, utils_1.killPorts)([serverConfig.ginPort]);
+            actions.push("released Go server port");
         }
+        actions.push(`started Go watcher on port ${serverConfig.ginPort}`);
+        (0, terminal_ui_1.printCommandSummary)("dev:go", actions);
         yield runGoDev();
     });
 }

package/commands/pack.js

@@ -58,6 +58,7 @@ const FS = __importStar(require("fs-extra"));
 const Path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
+const terminal_ui_1 = require("../src/terminal-ui");
 const { createJiti } = require("jiti");
 /**
  * 生成相对于服务器构建目录的绝对路径
@@ -96,7 +97,7 @@ const DEFAULT_FILES_TO_COPY = {
 // 兼容旧导出：默认构建目录下的绝对目标路径
 exports.FILES_TO_COPY = Object.fromEntries(Object.entries(DEFAULT_FILES_TO_COPY).map(([src, dest]) => [src, builtPath(dest)]));
 function warnPackConfig(message) {
-    console.warn(`[nuxt-gin-tools][pack] WARN: ${message}`);
+    (0, terminal_ui_1.printCommandWarn)(`[pack] ${message}`);
 }
 function errorPackConfig(message) {
     throw new Error(`[nuxt-gin-tools][pack] ${message}`);
@@ -147,7 +148,15 @@ function validatePackConfig(config, sourcePath) {
             issues.push({ level: "error", message: `${field} must be a string` });
         }
     }
-    const booleanFields = ["skipGo", "skipNuxt", "cleanDist", "writeScripts", "overwrite"];
+    const booleanFields = [
+        "skipGo",
+        "skipNuxt",
+        "skipBuild",
+        "skipZip",
+        "cleanDist",
+        "writeScripts",
+        "overwrite",
+    ];
     for (const field of booleanFields) {
         const value = typedConfig[field];
         if (value !== undefined && typeof value !== "boolean") {
@@ -172,6 +181,9 @@ function validatePackConfig(config, sourcePath) {
     if (typedConfig.skipGo === true && typedConfig.skipNuxt === true) {
         issues.push({ level: "warn", message: `skipGo and skipNuxt are both true; build step will be skipped` });
     }
+    if (typedConfig.skipBuild === true && typedConfig.skipZip === true) {
+        issues.push({ level: "warn", message: `skipBuild and skipZip are both true; only bundle assembly will run` });
+    }
     for (const issue of issues) {
         if (issue.level === "warn") {
             warnPackConfig(`${Path.basename(sourcePath)}: ${issue.message}`);
@@ -295,10 +307,11 @@ function makeZip(serverPath, zipPath) {
         // 使用 7zip 将服务器构建目录打包为 7z 文件
         Zip.pack(serverPath, zipPath, (error) => {
             if (error) {
-                console.error("打包失败:", error);
+                (0, terminal_ui_1.printCommandError)("打包失败", error);
                 reject(error);
+                return;
             }
-            console.log("打包成功:", zipPath);
+            (0, terminal_ui_1.printCommandSuccess)("pack", `archive ready: ${zipPath}`);
             resolve(zipPath);
         });
     });
@@ -325,22 +338,55 @@ function cleanUp(config) {
  */
 function buildAndPack(config) {
     return __awaiter(this, void 0, void 0, function* () {
+        (0, terminal_ui_1.printCommandBanner)("build", "Build project artifacts and pack deployment bundle");
+        const actions = [];
         const resolvedConfig = config !== null && config !== void 0 ? config : readPackConfigFromCwd();
         const serverPath = resolveServerPath(resolvedConfig);
         const zipPath = resolveZipPath(resolvedConfig);
-        yield (0, builder_1.default)(resolvedConfig); // 执行项目构建
+        if (!(resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.skipBuild)) {
+            yield (0, builder_1.default)(resolvedConfig); // 执行项目构建
+            actions.push("built project artifacts");
+        }
+        else {
+            (0, terminal_ui_1.printCommandInfo)("build", "skipping build step");
+            actions.push("skipped build step");
+        }
         if (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.beforePack) {
             yield resolvedConfig.beforePack();
+            actions.push("ran beforePack hook");
         }
         copyGeneratedFiles(serverPath, resolvedConfig); // 复制相关文件
+        actions.push(`assembled bundle in ${serverPath}`);
         if ((resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.writeScripts) !== false) {
             writeScriptFiles(serverPath, resolvedConfig); // 写入脚本文件
+            actions.push("wrote startup scripts and package.json");
+        }
+        else {
+            actions.push("skipped startup script generation");
         }
-        yield makeZip(serverPath, zipPath); // 打包文件
+        if (!(resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.skipZip)) {
+            yield makeZip(serverPath, zipPath); // 打包文件
+            (0, terminal_ui_1.printCommandInfo)("pack", `7z archive: ${zipPath}`);
+            actions.push(`created 7z archive at ${zipPath}`);
+        }
+        else {
+            (0, terminal_ui_1.printCommandInfo)("pack", "skipping 7z archive step");
+            actions.push("skipped 7z archive step");
+        }
+        (0, terminal_ui_1.printCommandInfo)("pack", `bundle dir: ${serverPath}`);
         if (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.afterPack) {
             yield resolvedConfig.afterPack(zipPath);
+            actions.push("ran afterPack hook");
         }
         cleanUp(resolvedConfig); // 清理临时文件
+        if ((resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.cleanDist) === false) {
+            actions.push("kept dist directory by configuration");
+        }
+        else {
+            actions.push("cleaned dist directory");
+        }
+        (0, terminal_ui_1.printCommandSuccess)("build", "Build and pack completed");
+        (0, terminal_ui_1.printCommandSummary)("build", actions);
     });
 }
 exports.default = buildAndPack;

package/commands/postinstall.d.ts

@@ -1,2 +1,6 @@
-export declare function postInstall(): Promise<import("concurrently").CloseEvent[]>;
+export type PostInstallOptions = {
+    skipGo?: boolean;
+    skipNuxt?: boolean;
+};
+export declare function postInstall(options?: PostInstallOptions): Promise<void>;
 export default postInstall;

package/commands/postinstall.js

@@ -6,27 +6,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.postInstall = postInstall;
 const concurrently_1 = __importDefault(require("concurrently"));
 const node_child_process_1 = require("node:child_process");
-function postInstall() {
+const terminal_ui_1 = require("../src/terminal-ui");
+function postInstall(options = {}) {
+    (0, terminal_ui_1.printCommandBanner)("install", "Prepare Nuxt and optional Go dependencies");
+    const actions = [];
+    const commands = [];
     const hasGo = (0, node_child_process_1.spawnSync)("go", ["version"], { stdio: "ignore", shell: true }).status ===
         0;
-    const commands = [
-        {
+    if (!options.skipNuxt) {
+        actions.push("prepared Nuxt runtime");
+        commands.push({
             command: "npx nuxt prepare",
             name: "nuxt",
             prefixColor: "blue",
-        },
-    ];
-    if (hasGo) {
-        commands.unshift({
+        });
+    }
+    if (!options.skipGo && hasGo) {
+        actions.push("downloaded and tidied Go modules");
+        commands.push({
             command: "go mod download && go mod tidy",
             name: "go",
             prefixColor: "green",
         });
     }
+    else if (!options.skipGo) {
+        (0, terminal_ui_1.printCommandWarn)("Go was not detected, skipping Go dependency bootstrap");
+        actions.push("skipped Go bootstrap because Go was not detected");
+    }
     else {
-        console.warn("[nuxt-gin-tools] 未检测到 Go，已跳过 Go 相关安装。请先安装 Go 后再重新运行相关命令。");
+        actions.push("skipped Go bootstrap by option");
+    }
+    if (options.skipNuxt) {
+        actions.push("skipped Nuxt prepare by option");
+    }
+    if (commands.length === 0) {
+        (0, terminal_ui_1.printCommandWarn)("Nothing selected for install, skipping bootstrap");
+        (0, terminal_ui_1.printCommandSummary)("install", actions.length > 0 ? actions : ["nothing was executed"]);
+        return Promise.resolve();
     }
     // 执行并发命令
-    return (0, concurrently_1.default)(commands).result;
+    return (0, concurrently_1.default)(commands).result.then(() => {
+        (0, terminal_ui_1.printCommandSuccess)("install", "Project bootstrap completed");
+        (0, terminal_ui_1.printCommandSummary)("install", actions);
+    });
 }
 exports.default = postInstall;

package/commands/update.d.ts

@@ -1,7 +1,9 @@
+import { type PackageManagerSelection } from "../src/package-manager";
 export type UpdateOptions = {
-    latest?: boolean;
+    latest: boolean;
+    packageManager: PackageManagerSelection;
     skipGo?: boolean;
     skipNode?: boolean;
 };
-export declare function update(options?: UpdateOptions): Promise<void> | Promise<import("concurrently").CloseEvent[]>;
+export declare function update(options: UpdateOptions): Promise<void>;
 export default update;

package/commands/update.js

@@ -5,25 +5,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.update = update;
 const concurrently_1 = __importDefault(require("concurrently"));
-function update(options = {}) {
+const package_manager_1 = require("../src/package-manager");
+const terminal_ui_1 = require("../src/terminal-ui");
+function update(options) {
+    (0, terminal_ui_1.printCommandBanner)("update", "Update Node and Go dependencies");
+    const actions = [];
     const commands = [];
+    const packageManager = (0, package_manager_1.resolvePackageManager)(options.packageManager);
     if (!options.skipNode) {
+        actions.push(`updated Node dependencies with ${packageManager} (${options.latest ? "latest" : "conservative"} mode)`);
         commands.push({
-            command: options.latest ? "pnpm update --latest" : "pnpm update",
-            name: "pnpm",
+            command: (0, package_manager_1.packageManagerUpdateCommand)(packageManager, options.latest),
+            name: packageManager,
             prefixColor: "magenta",
         });
     }
     if (!options.skipGo) {
+        actions.push(`updated Go modules with ${options.latest ? "latest" : "patch"} strategy`);
         commands.push({
             command: options.latest ? "go get -u ./... && go mod tidy" : "go get -u=patch ./... && go mod tidy",
             name: "go",
             prefixColor: "green",
         });
     }
+    if (options.skipNode) {
+        actions.push("skipped Node dependency update");
+    }
+    if (options.skipGo) {
+        actions.push("skipped Go dependency update");
+    }
     if (commands.length === 0) {
+        (0, terminal_ui_1.printCommandWarn)("No update targets selected, nothing to do");
+        (0, terminal_ui_1.printCommandSummary)("update", actions.length > 0 ? actions : ["nothing was executed"]);
         return Promise.resolve();
     }
-    return (0, concurrently_1.default)(commands).result;
+    return (0, concurrently_1.default)(commands).result.then(() => {
+        (0, terminal_ui_1.printCommandSuccess)("update", "Dependency update completed");
+        (0, terminal_ui_1.printCommandSummary)("update", actions);
+    });
 }
 exports.default = update;

package/index.js

@@ -51,8 +51,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const pack_1 = __importDefault(require("./commands/pack"));
 // 导入开发模式功能
 const develop_1 = __importStar(require("./commands/develop"));
-// 导入API生成功能
-const api_generate_1 = __importDefault(require("./commands/api-generate"));
 // 导入安装后处理功能
 const postinstall_1 = __importDefault(require("./commands/postinstall"));
 // 导入清理功能
@@ -60,17 +58,25 @@ const cleanup_1 = __importDefault(require("./commands/cleanup"));
 // 导入更新功能
 const update_1 = __importDefault(require("./commands/update"));
 const cli_options_1 = require("./src/cli-options");
+const package_manager_1 = require("./src/package-manager");
+const terminal_ui_1 = require("./src/terminal-ui");
 // 获取命令行参数（去除前两个默认参数）
 const args = process.argv.slice(2);
 // 检查是否提供了命令
 if (args.length === 0) {
-    console.error("未提供命令。请指定要运行的命令。");
+    (0, terminal_ui_1.printCommandError)("未提供命令。请指定要运行的命令。");
     process.exit(1);
 }
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const command = args[0];
         const options = (0, cli_options_1.parseCLIOptions)(args.slice(1));
+        const rawPackageManager = (0, cli_options_1.getOption)(options, "package-manager");
+        const packageManagerCandidate = rawPackageManager !== null && rawPackageManager !== void 0 ? rawPackageManager : "auto";
+        if (!(0, package_manager_1.isPackageManagerSelection)(packageManagerCandidate)) {
+            throw new Error(`Invalid value for --package-manager: ${packageManagerCandidate}. Expected one of: auto, bun, pnpm, npm`);
+        }
+        const packageManagerOption = packageManagerCandidate;
         switch (command) {
             case "dev":
                 yield (0, develop_1.default)({
@@ -94,35 +100,39 @@ function main() {
                     binaryName: (0, cli_options_1.getOption)(options, "binary-name"),
                     skipGo: (0, cli_options_1.hasFlag)(options, "skip-go"),
                     skipNuxt: (0, cli_options_1.hasFlag)(options, "skip-nuxt"),
+                    skipBuild: (0, cli_options_1.hasFlag)(options, "skip-build"),
+                    skipZip: (0, cli_options_1.hasFlag)(options, "skip-zip"),
                 });
                 break;
-            case "gen":
-                // 生成API代码（注：此处命令可能拼写错误，应为generate）
-                yield (0, api_generate_1.default)();
-                break;
             case "install":
                 // 执行安装后的初始化操作
-                yield (0, postinstall_1.default)();
+                yield (0, postinstall_1.default)({
+                    skipGo: (0, cli_options_1.hasFlag)(options, "skip-go"),
+                    skipNuxt: (0, cli_options_1.hasFlag)(options, "skip-nuxt"),
+                });
                 break;
             case "cleanup":
                 // 执行清理操作
-                yield (0, cleanup_1.default)();
+                yield (0, cleanup_1.default)({
+                    dryRun: (0, cli_options_1.hasFlag)(options, "dry-run"),
+                });
                 break;
             case "update":
                 // 更新依赖
                 yield (0, update_1.default)({
-                    latest: (0, cli_options_1.hasFlag)(options, "latest"),
+                    latest: (0, cli_options_1.getBooleanOption)(options, "latest", false),
+                    packageManager: packageManagerOption,
                     skipGo: (0, cli_options_1.hasFlag)(options, "skip-go"),
                     skipNode: (0, cli_options_1.hasFlag)(options, "skip-node"),
                 });
                 break;
             default:
-                console.error(`未知命令: ${command}`);
+                (0, terminal_ui_1.printCommandError)(`未知命令: ${command}`);
                 process.exit(1);
         }
     });
 }
 void main().catch((error) => {
-    console.error(error);
+    (0, terminal_ui_1.printCommandError)("命令执行失败", error);
     process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-gin-tools",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "This project is used as a dependency for [nuxt-gin-starter](https://github.com/RapboyGao/nuxt-gin-starter.git)",
   "bin": {
     "nuxt-gin": "index.js"

package/src/cli-options.d.ts

@@ -6,3 +6,4 @@ export type CLIOptions = {
 export declare function parseCLIOptions(args: string[]): CLIOptions;
 export declare function hasFlag(options: CLIOptions, key: string): boolean;
 export declare function getOption(options: CLIOptions, key: string): string | undefined;
+export declare function getBooleanOption(options: CLIOptions, key: string, defaultValue: boolean): boolean;

package/src/cli-options.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCLIOptions = parseCLIOptions;
 exports.hasFlag = hasFlag;
 exports.getOption = getOption;
+exports.getBooleanOption = getBooleanOption;
 function normalizeKey(key) {
     return key.replace(/^-+/, "").trim();
 }
@@ -41,3 +42,17 @@ function hasFlag(options, key) {
 function getOption(options, key) {
     return options.values.get(normalizeKey(key));
 }
+function getBooleanOption(options, key, defaultValue) {
+    const value = getOption(options, key);
+    if (value === undefined) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "y", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["false", "0", "no", "n", "off"].includes(normalized)) {
+        return false;
+    }
+    throw new Error(`Invalid boolean value for --${key}: ${value}`);
+}

package/src/pack.d.ts

@@ -1,5 +1,13 @@
 import type { BuildOptions } from "../commands/builder";
 export interface PackConfig extends BuildOptions {
+    /**
+     * 是否跳过构建步骤
+     */
+    skipBuild?: boolean;
+    /**
+     * 是否跳过 7z 打包步骤
+     */
+    skipZip?: boolean;
     /**
      * 额外需要打包的文件映射
      * key: 源文件路径（相对于项目根目录或绝对路径）

package/src/package-manager.d.ts

@@ -0,0 +1,7 @@
+export type PackageManager = "bun" | "pnpm" | "npm";
+export type PackageManagerSelection = PackageManager | "auto";
+export declare const PACKAGE_MANAGER_SELECTIONS: readonly ["auto", "bun", "pnpm", "npm"];
+export declare function detectPackageManager(): PackageManager;
+export declare function resolvePackageManager(selection: PackageManagerSelection): PackageManager;
+export declare function isPackageManagerSelection(value: string): value is PackageManagerSelection;
+export declare function packageManagerUpdateCommand(packageManager: PackageManager, latest: boolean): string;

package/src/package-manager.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_MANAGER_SELECTIONS = void 0;
+exports.detectPackageManager = detectPackageManager;
+exports.resolvePackageManager = resolvePackageManager;
+exports.isPackageManagerSelection = isPackageManagerSelection;
+exports.packageManagerUpdateCommand = packageManagerUpdateCommand;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+exports.PACKAGE_MANAGER_SELECTIONS = ["auto", "bun", "pnpm", "npm"];
+const cwd = process.cwd();
+function detectPackageManager() {
+    if ((0, fs_extra_1.existsSync)((0, path_1.join)(cwd, "bun.lock")) || (0, fs_extra_1.existsSync)((0, path_1.join)(cwd, "bun.lockb"))) {
+        return "bun";
+    }
+    if ((0, fs_extra_1.existsSync)((0, path_1.join)(cwd, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    return "npm";
+}
+function resolvePackageManager(selection) {
+    if (selection === "auto") {
+        return detectPackageManager();
+    }
+    return selection;
+}
+function isPackageManagerSelection(value) {
+    return exports.PACKAGE_MANAGER_SELECTIONS.includes(value);
+}
+function packageManagerUpdateCommand(packageManager, latest) {
+    switch (packageManager) {
+        case "bun":
+            return latest ? "bun update --latest" : "bun update";
+        case "pnpm":
+            return latest ? "pnpm update --latest" : "pnpm update";
+        default:
+            return latest ? "npm update" : "npm update";
+    }
+}

package/src/terminal-ui.d.ts

@@ -0,0 +1,7 @@
+export declare function printCommandBanner(command: string, subtitle: string): void;
+export declare function printCommandSuccess(command: string, message: string): void;
+export declare function printCommandInfo(label: string, message: string): void;
+export declare function printCommandWarn(message: string): void;
+export declare function printCommandError(message: string, error?: unknown): void;
+export declare function printCommandLog(label: string, message: string): void;
+export declare function printCommandSummary(command: string, items: string[]): void;

package/src/terminal-ui.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printCommandBanner = printCommandBanner;
+exports.printCommandSuccess = printCommandSuccess;
+exports.printCommandInfo = printCommandInfo;
+exports.printCommandWarn = printCommandWarn;
+exports.printCommandError = printCommandError;
+exports.printCommandLog = printCommandLog;
+exports.printCommandSummary = printCommandSummary;
+const chalk_1 = __importDefault(require("chalk"));
+const TERMINAL_WIDTH = 72;
+function printLine(message, method = "log") {
+    if (method === "warn") {
+        console.warn(message);
+        return;
+    }
+    if (method === "error") {
+        console.error(message);
+        return;
+    }
+    console.log(message);
+}
+function repeat(char, width = TERMINAL_WIDTH) {
+    return char.repeat(width);
+}
+function formatClock() {
+    return new Date().toLocaleTimeString("en-GB", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    });
+}
+function padText(value, width) {
+    const text = value.length > width ? `${value.slice(0, Math.max(0, width - 1))}…` : value;
+    return text + " ".repeat(Math.max(0, width - text.length));
+}
+function sectionBorder(color) {
+    return color(`╭${repeat("─", TERMINAL_WIDTH - 2)}╮`);
+}
+function sectionFooter(color) {
+    return color(`╰${repeat("─", TERMINAL_WIDTH - 2)}╯`);
+}
+function sectionBody(text, color) {
+    return color(`│ ${padText(text, TERMINAL_WIDTH - 4)} │`);
+}
+function printSection(lines, options) {
+    var _a;
+    if (lines.length === 0) {
+        return;
+    }
+    const method = (_a = options.method) !== null && _a !== void 0 ? _a : "log";
+    printLine(options.color(``), method);
+    printLine(sectionBorder(options.color), method);
+    for (const line of lines) {
+        printLine(sectionBody(line, options.color), method);
+    }
+    printLine(sectionFooter(options.color), method);
+}
+function commandChip(command) {
+    return chalk_1.default.bgBlueBright.black(` ${command.toUpperCase()} `);
+}
+function subtleChip(text) {
+    return chalk_1.default.bgBlackBright.white(` ${text} `);
+}
+function printCommandBanner(command, subtitle) {
+    const timestamp = subtleChip(formatClock());
+    const title = `nuxt-gin-tools ${commandChip(command)} ${timestamp}`;
+    const detail = chalk_1.default.cyanBright(subtitle);
+    printLine("");
+    printSection([title, detail], {
+        color: chalk_1.default.blueBright,
+    });
+}
+function printCommandSuccess(command, message) {
+    printLine(chalk_1.default.greenBright(`◆ ${chalk_1.default.bold(command)} completed`) + chalk_1.default.green(`  ${message}`));
+}
+function printCommandInfo(label, message) {
+    const head = chalk_1.default.bgCyan.black(` ${label.toUpperCase()} `);
+    printLine(`${head} ${chalk_1.default.cyanBright(message)}`);
+}
+function printCommandWarn(message) {
+    printSection([`${chalk_1.default.bold("warning")}  ${message}`], {
+        color: chalk_1.default.yellow,
+        method: "warn",
+    });
+}
+function printCommandError(message, error) {
+    const detail = error instanceof Error ? error.message : error !== undefined ? String(error) : "";
+    const lines = [`${chalk_1.default.bold("error")}  ${message}`];
+    if (detail) {
+        lines.push(chalk_1.default.redBright(detail));
+    }
+    printSection(lines, {
+        color: chalk_1.default.red,
+        method: "error",
+    });
+}
+function printCommandLog(label, message) {
+    const chip = chalk_1.default.bgMagenta.white(` ${label} `);
+    printLine(`${chip} ${chalk_1.default.white(message)}`);
+}
+function printCommandSummary(command, items) {
+    const normalizedItems = items.map((item) => item.trim()).filter(Boolean);
+    if (normalizedItems.length === 0) {
+        return;
+    }
+    const lines = [
+        `${chalk_1.default.bold(`${command} summary`)}  ${chalk_1.default.gray(`(${normalizedItems.length} items)`)}`,
+        ...normalizedItems.map((item) => chalk_1.default.magenta(`• ${item}`)),
+    ];
+    printSection(lines, {
+        color: chalk_1.default.magentaBright,
+    });
+}

package/src/utils.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.killPort = killPort;
 exports.killPorts = killPorts;
 const child_process_1 = require("child_process");
-const chalk_1 = __importDefault(require("chalk"));
 const os_1 = __importDefault(require("os"));
+const terminal_ui_1 = require("./terminal-ui");
 function isValidPort(port) {
     return Number.isInteger(port) && port > 0;
 }
@@ -34,7 +34,7 @@ function killPortUnix(port, options) {
         for (const pid of pids) {
             try {
                 process.kill(pid, "SIGKILL");
-                console.log(chalk_1.default.green(buildMessage(pid, port, "unix", options)));
+                (0, terminal_ui_1.printCommandSuccess)("port", buildMessage(pid, port, "unix", options));
             }
             catch (_a) {
                 // Best-effort: if the process is already gone, ignore.
@@ -81,7 +81,7 @@ function killPortWindows(port, options) {
                 (0, child_process_1.execSync)(`taskkill /PID ${pid} /F`, {
                     stdio: ["ignore", "ignore", "ignore"],
                 });
-                console.log(chalk_1.default.green(buildMessage(pid, port, "win32", options)));
+                (0, terminal_ui_1.printCommandSuccess)("port", buildMessage(pid, port, "win32", options));
             }
             catch (_a) {
                 // Best-effort: if the process is already gone, ignore.