create-rstack 1.7.10 → 1.7.12

package/dist/index.d.ts

@@ -12,6 +12,11 @@ export declare const BUILTIN_TOOLS: string[];
 
 export declare function checkCancel<T>(value: unknown): T;
 
+/**
+ * Collect AGENTS.md files from template directories
+ */
+export declare function collectAgentsFiles(agentsMdSearchDirs: string[]): string[];
+
 /**
  * Copy files from one folder to another.
  * @param from Source folder
@@ -31,21 +36,57 @@ export declare function copyFolder({ from, to, version, packageName, templatePar
     skipFiles?: string[];
 }): void;
 
-export declare function create({ name, root, templates, skipFiles, getTemplateName, mapESLintTemplate, version, noteInformation, }: {
+export declare function create({ name, root, templates, skipFiles, getTemplateName, mapESLintTemplate, version, noteInformation, extraTools, argv: processArgv, }: {
     name: string;
     root: string;
     skipFiles?: string[];
     templates: string[];
     getTemplateName: (argv: Argv) => Promise<string>;
-    mapESLintTemplate: (templateName: string, context: {
+    /**
+     * Map the template name to the ESLint template name.
+     * If not provided, defaults to 'vanilla-ts' for all templates.
+     */
+    mapESLintTemplate?: (templateName: string, context: {
         distFolder: string;
     }) => ESLintTemplateName | null;
     version?: Record<string, string> | string;
     noteInformation?: string[];
+    /**
+     * Specify additional tools.
+     */
+    extraTools?: ExtraTool[];
+    /**
+     * For test purpose, override the default argv (process.argv).
+     */
+    argv?: string[];
 }): Promise<void>;
 
 export declare type ESLintTemplateName = 'vanilla-js' | 'vanilla-ts' | 'react-js' | 'react-ts' | 'vue-ts' | 'vue-js' | 'svelte-js' | 'svelte-ts';
 
+declare type ExtraTool = {
+    /**
+     * The value of the multiselect option.
+     */
+    value: string;
+    /**
+     * The label of the multiselect option.
+     */
+    label: string;
+    /**
+     * The action to perform when the tool is selected.
+     */
+    action?: () => unknown;
+    /**
+     * The custom command to run when the tool is selected.
+     */
+    command?: string;
+};
+
+/**
+ * Merge AGENTS.md files from multiple sources
+ */
+export declare function mergeAgentsFiles(agentsFiles: string[]): string;
+
 /**
  * Merge two package.json files and keep the order of keys.
  * @param targetPackage Path to the base package.json file

package/dist/index.js

@@ -1,5 +1,8 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
+import * as __rspack_external_child_process from "child_process";
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_path from "path";
 import node_fs from "node:fs";
 import node_path, { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -10,6 +13,192 @@ import { Writable } from "node:stream";
 import node_os from "node:os";
 import node_tty from "node:tty";
 var __webpack_modules__ = {
+    "./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const cp = __webpack_require__("child_process");
+        const parse = __webpack_require__("./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js");
+        const enoent = __webpack_require__("./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js");
+        function spawn(command, args, options) {
+            const parsed = parse(command, args, options);
+            const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+            enoent.hookChildProcess(spawned, parsed);
+            return spawned;
+        }
+        function spawnSync(command, args, options) {
+            const parsed = parse(command, args, options);
+            const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+            result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+            return result;
+        }
+        module.exports = spawn;
+        module.exports.spawn = spawn;
+        module.exports.sync = spawnSync;
+        module.exports._parse = parse;
+        module.exports._enoent = enoent;
+    },
+    "./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js": function(module) {
+        const isWin = 'win32' === process.platform;
+        function notFoundError(original, syscall) {
+            return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+                code: 'ENOENT',
+                errno: 'ENOENT',
+                syscall: `${syscall} ${original.command}`,
+                path: original.command,
+                spawnargs: original.args
+            });
+        }
+        function hookChildProcess(cp, parsed) {
+            if (!isWin) return;
+            const originalEmit = cp.emit;
+            cp.emit = function(name, arg1) {
+                if ('exit' === name) {
+                    const err = verifyENOENT(arg1, parsed);
+                    if (err) return originalEmit.call(cp, 'error', err);
+                }
+                return originalEmit.apply(cp, arguments);
+            };
+        }
+        function verifyENOENT(status, parsed) {
+            if (isWin && 1 === status && !parsed.file) return notFoundError(parsed.original, 'spawn');
+            return null;
+        }
+        function verifyENOENTSync(status, parsed) {
+            if (isWin && 1 === status && !parsed.file) return notFoundError(parsed.original, 'spawnSync');
+            return null;
+        }
+        module.exports = {
+            hookChildProcess,
+            verifyENOENT,
+            verifyENOENTSync,
+            notFoundError
+        };
+    },
+    "./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const resolveCommand = __webpack_require__("./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js");
+        const escape = __webpack_require__("./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js");
+        const readShebang = __webpack_require__("./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js");
+        const isWin = 'win32' === process.platform;
+        const isExecutableRegExp = /\.(?:com|exe)$/i;
+        const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+        function detectShebang(parsed) {
+            parsed.file = resolveCommand(parsed);
+            const shebang = parsed.file && readShebang(parsed.file);
+            if (shebang) {
+                parsed.args.unshift(parsed.file);
+                parsed.command = shebang;
+                return resolveCommand(parsed);
+            }
+            return parsed.file;
+        }
+        function parseNonShell(parsed) {
+            if (!isWin) return parsed;
+            const commandFile = detectShebang(parsed);
+            const needsShell = !isExecutableRegExp.test(commandFile);
+            if (parsed.options.forceShell || needsShell) {
+                const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+                parsed.command = path.normalize(parsed.command);
+                parsed.command = escape.command(parsed.command);
+                parsed.args = parsed.args.map((arg)=>escape.argument(arg, needsDoubleEscapeMetaChars));
+                const shellCommand = [
+                    parsed.command
+                ].concat(parsed.args).join(' ');
+                parsed.args = [
+                    '/d',
+                    '/s',
+                    '/c',
+                    `"${shellCommand}"`
+                ];
+                parsed.command = process.env.comspec || 'cmd.exe';
+                parsed.options.windowsVerbatimArguments = true;
+            }
+            return parsed;
+        }
+        function parse(command, args, options) {
+            if (args && !Array.isArray(args)) {
+                options = args;
+                args = null;
+            }
+            args = args ? args.slice(0) : [];
+            options = Object.assign({}, options);
+            const parsed = {
+                command,
+                args,
+                options,
+                file: void 0,
+                original: {
+                    command,
+                    args
+                }
+            };
+            return options.shell ? parsed : parseNonShell(parsed);
+        }
+        module.exports = parse;
+    },
+    "./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js": function(module) {
+        const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+        function escapeCommand(arg) {
+            arg = arg.replace(metaCharsRegExp, '^$1');
+            return arg;
+        }
+        function escapeArgument(arg, doubleEscapeMetaChars) {
+            arg = `${arg}`;
+            arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+            arg = arg.replace(/(?=(\\+?)?)\1$/, '$1$1');
+            arg = `"${arg}"`;
+            arg = arg.replace(metaCharsRegExp, '^$1');
+            if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, '^$1');
+            return arg;
+        }
+        module.exports.command = escapeCommand;
+        module.exports.argument = escapeArgument;
+    },
+    "./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const fs = __webpack_require__("fs");
+        const shebangCommand = __webpack_require__("./node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js");
+        function readShebang(command) {
+            const size = 150;
+            const buffer = Buffer.alloc(size);
+            let fd;
+            try {
+                fd = fs.openSync(command, 'r');
+                fs.readSync(fd, buffer, 0, size, 0);
+                fs.closeSync(fd);
+            } catch (e) {}
+            return shebangCommand(buffer.toString());
+        }
+        module.exports = readShebang;
+    },
+    "./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const which = __webpack_require__("./node_modules/.pnpm/which@2.0.2/node_modules/which/which.js");
+        const getPathKey = __webpack_require__("./node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js");
+        function resolveCommandAttempt(parsed, withoutPathExt) {
+            const env = parsed.options.env || process.env;
+            const cwd = process.cwd();
+            const hasCustomCwd = null != parsed.options.cwd;
+            const shouldSwitchCwd = hasCustomCwd && void 0 !== process.chdir && !process.chdir.disabled;
+            if (shouldSwitchCwd) try {
+                process.chdir(parsed.options.cwd);
+            } catch (err) {}
+            let resolved;
+            try {
+                resolved = which.sync(parsed.command, {
+                    path: env[getPathKey({
+                        env
+                    })],
+                    pathExt: withoutPathExt ? path.delimiter : void 0
+                });
+            } catch (e) {} finally{
+                if (shouldSwitchCwd) process.chdir(cwd);
+            }
+            if (resolved) resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
+            return resolved;
+        }
+        function resolveCommand(parsed) {
+            return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+        }
+        module.exports = resolveCommand;
+    },
     "./node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js": function(module) {
         var isMergeableObject = function(value) {
             return isNonNullObject(value) && !isSpecial(value);
@@ -93,6 +282,102 @@ var __webpack_modules__ = {
         var deepmerge_1 = deepmerge;
         module.exports = deepmerge_1;
     },
+    "./node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        __webpack_require__("fs");
+        var core;
+        core = 'win32' === process.platform || global.TESTING_WINDOWS ? __webpack_require__("./node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js") : __webpack_require__("./node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js");
+        module.exports = isexe;
+        isexe.sync = sync;
+        function isexe(path, options, cb) {
+            if ('function' == typeof options) {
+                cb = options;
+                options = {};
+            }
+            if (!cb) {
+                if ('function' != typeof Promise) throw new TypeError('callback not provided');
+                return new Promise(function(resolve, reject) {
+                    isexe(path, options || {}, function(er, is) {
+                        if (er) reject(er);
+                        else resolve(is);
+                    });
+                });
+            }
+            core(path, options || {}, function(er, is) {
+                if (er) {
+                    if ('EACCES' === er.code || options && options.ignoreErrors) {
+                        er = null;
+                        is = false;
+                    }
+                }
+                cb(er, is);
+            });
+        }
+        function sync(path, options) {
+            try {
+                return core.sync(path, options || {});
+            } catch (er) {
+                if (options && options.ignoreErrors || 'EACCES' === er.code) return false;
+                throw er;
+            }
+        }
+    },
+    "./node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        module.exports = isexe;
+        isexe.sync = sync;
+        var fs = __webpack_require__("fs");
+        function isexe(path, options, cb) {
+            fs.stat(path, function(er, stat) {
+                cb(er, er ? false : checkStat(stat, options));
+            });
+        }
+        function sync(path, options) {
+            return checkStat(fs.statSync(path), options);
+        }
+        function checkStat(stat, options) {
+            return stat.isFile() && checkMode(stat, options);
+        }
+        function checkMode(stat, options) {
+            var mod = stat.mode;
+            var uid = stat.uid;
+            var gid = stat.gid;
+            var myUid = void 0 !== options.uid ? options.uid : process.getuid && process.getuid();
+            var myGid = void 0 !== options.gid ? options.gid : process.getgid && process.getgid();
+            var u = parseInt('100', 8);
+            var g = parseInt('010', 8);
+            var o = parseInt('001', 8);
+            var ug = u | g;
+            var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && 0 === myUid;
+            return ret;
+        }
+    },
+    "./node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        module.exports = isexe;
+        isexe.sync = sync;
+        var fs = __webpack_require__("fs");
+        function checkPathExt(path, options) {
+            var pathext = void 0 !== options.pathExt ? options.pathExt : process.env.PATHEXT;
+            if (!pathext) return true;
+            pathext = pathext.split(';');
+            if (-1 !== pathext.indexOf('')) return true;
+            for(var i = 0; i < pathext.length; i++){
+                var p = pathext[i].toLowerCase();
+                if (p && path.substr(-p.length).toLowerCase() === p) return true;
+            }
+            return false;
+        }
+        function checkStat(stat, path, options) {
+            if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+            return checkPathExt(path, options);
+        }
+        function isexe(path, options, cb) {
+            fs.stat(path, function(er, stat) {
+                cb(er, er ? false : checkStat(stat, path, options));
+            });
+        }
+        function sync(path, options) {
+            return checkStat(fs.statSync(path), path, options);
+        }
+    },
     "./node_modules/.pnpm/minimist@1.2.8/node_modules/minimist/index.js": function(module) {
         function hasKey(obj, keys) {
             var o = obj;
@@ -272,6 +557,16 @@ var __webpack_modules__ = {
             return argv;
         };
     },
+    "./node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js": function(module) {
+        const pathKey = (options = {})=>{
+            const environment = options.env || process.env;
+            const platform = options.platform || process.platform;
+            if ('win32' !== platform) return 'PATH';
+            return Object.keys(environment).reverse().find((key)=>'PATH' === key.toUpperCase()) || 'Path';
+        };
+        module.exports = pathKey;
+        module.exports["default"] = pathKey;
+    },
     "./node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js": function(module) {
         let p = process || {}, argv = p.argv || [], env = p.env || {};
         let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
@@ -338,6 +633,20 @@ var __webpack_modules__ = {
         module.exports = createColors();
         module.exports.createColors = createColors;
     },
+    "./node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const shebangRegex = __webpack_require__("./node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js");
+        module.exports = (string = '')=>{
+            const match = string.match(shebangRegex);
+            if (!match) return null;
+            const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
+            const binary = path.split('/').pop();
+            if ('env' === binary) return argument;
+            return argument ? `${binary} ${argument}` : binary;
+        };
+    },
+    "./node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js": function(module) {
+        module.exports = /^#!(.*)/;
+    },
     "./node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js": function(module) {
         const ESC = '\x1B';
         const CSI = `${ESC}[`;
@@ -391,6 +700,102 @@ var __webpack_modules__ = {
             erase,
             beep
         };
+    },
+    "./node_modules/.pnpm/which@2.0.2/node_modules/which/which.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const isWindows = 'win32' === process.platform || 'cygwin' === process.env.OSTYPE || 'msys' === process.env.OSTYPE;
+        const path = __webpack_require__("path");
+        const COLON = isWindows ? ';' : ':';
+        const isexe = __webpack_require__("./node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js");
+        const getNotFoundError = (cmd)=>Object.assign(new Error(`not found: ${cmd}`), {
+                code: 'ENOENT'
+            });
+        const getPathInfo = (cmd, opt)=>{
+            const colon = opt.colon || COLON;
+            const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [
+                ''
+            ] : [
+                ...isWindows ? [
+                    process.cwd()
+                ] : [],
+                ...(opt.path || process.env.PATH || '').split(colon)
+            ];
+            const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM' : '';
+            const pathExt = isWindows ? pathExtExe.split(colon) : [
+                ''
+            ];
+            if (isWindows) {
+                if (-1 !== cmd.indexOf('.') && '' !== pathExt[0]) pathExt.unshift('');
+            }
+            return {
+                pathEnv,
+                pathExt,
+                pathExtExe
+            };
+        };
+        const which = (cmd, opt, cb)=>{
+            if ('function' == typeof opt) {
+                cb = opt;
+                opt = {};
+            }
+            if (!opt) opt = {};
+            const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+            const found = [];
+            const step = (i)=>new Promise((resolve, reject)=>{
+                    if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+                    const ppRaw = pathEnv[i];
+                    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+                    const pCmd = path.join(pathPart, cmd);
+                    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+                    resolve(subStep(p, i, 0));
+                });
+            const subStep = (p, i, ii)=>new Promise((resolve, reject)=>{
+                    if (ii === pathExt.length) return resolve(step(i + 1));
+                    const ext = pathExt[ii];
+                    isexe(p + ext, {
+                        pathExt: pathExtExe
+                    }, (er, is)=>{
+                        if (!er && is) if (!opt.all) return resolve(p + ext);
+                        else found.push(p + ext);
+                        return resolve(subStep(p, i, ii + 1));
+                    });
+                });
+            return cb ? step(0).then((res)=>cb(null, res), cb) : step(0);
+        };
+        const whichSync = (cmd, opt)=>{
+            opt = opt || {};
+            const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+            const found = [];
+            for(let i = 0; i < pathEnv.length; i++){
+                const ppRaw = pathEnv[i];
+                const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+                const pCmd = path.join(pathPart, cmd);
+                const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+                for(let j = 0; j < pathExt.length; j++){
+                    const cur = p + pathExt[j];
+                    try {
+                        const is = isexe.sync(cur, {
+                            pathExt: pathExtExe
+                        });
+                        if (is) if (!opt.all) return cur;
+                        else found.push(cur);
+                    } catch (ex) {}
+                }
+            }
+            if (opt.all && found.length) return found;
+            if (opt.nothrow) return null;
+            throw getNotFoundError(cmd);
+        };
+        module.exports = which;
+        which.sync = whichSync;
+    },
+    child_process: function(module) {
+        module.exports = __rspack_external_child_process;
+    },
+    fs: function(module) {
+        module.exports = __rspack_external_fs;
+    },
+    path: function(module) {
+        module.exports = __rspack_external_path;
     }
 };
 var __webpack_module_cache__ = {};
@@ -1281,6 +1686,8 @@ ${picocolors.gray(dist_d)}  ${t}
 `);
 };
 picocolors.gray(dist_o);
+var cross_spawn = __webpack_require__("./node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js");
+var cross_spawn_default = /*#__PURE__*/ __webpack_require__.n(cross_spawn);
 var cjs = __webpack_require__("./node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js");
 var cjs_default = /*#__PURE__*/ __webpack_require__.n(cjs);
 var minimist = __webpack_require__("./node_modules/.pnpm/minimist@1.2.8/node_modules/minimist/index.js");
@@ -1387,9 +1794,10 @@ const supportsColor = {
 };
 const supports_color = supportsColor;
 const colorLevel = supports_color.stdout ? supports_color.stdout.level : 0;
-let errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
-let anonymousErrorStackRegExp = /at\s.*\(<anonymous>\)$/;
-let isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
+let errorStackRegExp = /at [^\r\n]{0,200}:\d+:\d+[\s\)]*$/;
+let anonymousErrorStackRegExp = /at [^\r\n]{0,200}\(<anonymous>\)$/;
+let indexErrorStackRegExp = /at [^\r\n]{0,200}\(index\s\d+\)$/;
+let isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message) || indexErrorStackRegExp.test(message);
 let formatter = (open, close, replace = open)=>colorLevel >= 2 ? (input)=>{
         let string = '' + input;
         let index = string.indexOf(close, open.length);
@@ -1501,9 +1909,10 @@ const normalizeErrorMessage = (err)=>{
 let createLogger = (options = {})=>{
     let maxLevel = options.level || 'info';
     let log = (type, message, ...args)=>{
-        if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) return;
-        if (null == message) return console.log();
         let logType = LOG_TYPES[type];
+        const { level } = logType;
+        if (LOG_LEVEL[level] > LOG_LEVEL[maxLevel]) return;
+        if (null == message) return console.log();
         let label = '';
         let text = '';
         if ('label' in logType) {
@@ -1517,11 +1926,12 @@ let createLogger = (options = {})=>{
                 text += yellow('\n  [cause]: ');
                 text += cause instanceof Error ? normalizeErrorMessage(cause) : String(cause);
             }
-        } else if ('error' === logType.level && 'string' == typeof message) {
+        } else if ('error' === level && 'string' == typeof message) {
             let lines = message.split('\n');
             text = lines.map((line)=>isErrorStackMessage(line) ? gray(line) : line).join('\n');
         } else text = `${message}`;
-        console.log(label.length ? `${label} ${text}` : text, ...args);
+        const method = 'error' === level || 'warn' === level ? level : 'log';
+        console[method](label.length ? `${label} ${text}` : text, ...args);
     };
     let logger = {
         greet: (message)=>log('log', gradient(message))
@@ -1594,32 +2004,38 @@ function logHelpMessage(name, templates) {
      ${templates.join(', ')}
 `);
 }
-async function getTools({ tools, dir, template }) {
+async function getTools({ tools, dir, template }, extraTools) {
     if (tools) {
         let toolsArr = Array.isArray(tools) ? tools : [
             tools
         ];
-        toolsArr = toolsArr.filter((tool)=>BUILTIN_TOOLS.includes(tool));
+        toolsArr = toolsArr.filter((tool)=>BUILTIN_TOOLS.includes(tool) || extraTools?.some((extraTool)=>extraTool.value === tool));
         return toolsArr;
     }
     if (dir && template) return [];
     if ('' === tools) return [];
+    const options = [
+        {
+            value: 'biome',
+            label: 'Add Biome for code linting and formatting'
+        },
+        {
+            value: 'eslint',
+            label: 'Add ESLint for code linting'
+        },
+        {
+            value: 'prettier',
+            label: 'Add Prettier for code formatting'
+        }
+    ];
+    if (extraTools) options.push(...extraTools.map((tool)=>({
+            value: tool.value,
+            label: tool.label,
+            hint: tool.command
+        })));
     return checkCancel(await fe({
         message: 'Select additional tools (Use <space> to select, <enter> to continue)',
-        options: [
-            {
-                value: 'biome',
-                label: 'Add Biome for code linting and formatting'
-            },
-            {
-                value: 'eslint',
-                label: 'Add ESLint for code linting'
-            },
-            {
-                value: 'prettier',
-                label: 'Add Prettier for code formatting'
-            }
-        ],
+        options,
         required: false
     }));
 }
@@ -1628,8 +2044,8 @@ function upperFirst(str) {
 }
 const readJSON = async (path)=>JSON.parse(await node_fs.promises.readFile(path, 'utf-8'));
 const readPackageJson = async (filePath)=>readJSON(node_path.join(filePath, 'package.json'));
-const parseArgv = ()=>{
-    const argv = minimist_default()(process.argv.slice(2), {
+const parseArgv = (processArgv)=>{
+    const argv = minimist_default()(processArgv.slice(2), {
         alias: {
             h: 'help',
             d: 'dir',
@@ -1640,10 +2056,17 @@ const parseArgv = ()=>{
     if (argv['package-name']) argv.packageName = argv['package-name'];
     return argv;
 };
-async function create({ name, root, templates, skipFiles, getTemplateName, mapESLintTemplate, version, noteInformation }) {
+function runCommand(command, cwd) {
+    const [bin, ...args] = command.split(' ');
+    cross_spawn_default().sync(bin, args, {
+        stdio: 'inherit',
+        cwd
+    });
+}
+async function create({ name, root, templates, skipFiles, getTemplateName, mapESLintTemplate, version, noteInformation, extraTools, argv: processArgv = process.argv }) {
     console.log('');
     src_logger.greet(`◆  Create ${upperFirst(name)} Project`);
-    const argv = parseArgv();
+    const argv = parseArgv(processArgv);
     if (argv.help) return void logHelpMessage(name, templates);
     const cwd = process.cwd();
     const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent);
@@ -1681,7 +2104,7 @@ async function create({ name, root, templates, skipFiles, getTemplateName, mapES
         if ('no' === option) cancelAndExit();
     }
     const templateName = await getTemplateName(argv);
-    const tools = await getTools(argv);
+    const tools = await getTools(argv, extraTools);
     const srcFolder = node_path.join(root, `template-${templateName}`);
     const commonFolder = node_path.join(root, 'template-common');
     if (!node_fs.existsSync(srcFolder)) throw new Error(`Invalid input: template "${templateName}" not found.`);
@@ -1706,11 +2129,17 @@ async function create({ name, root, templates, skipFiles, getTemplateName, mapES
         srcFolder
     ];
     for (const tool of tools){
+        if (extraTools) {
+            const matchedTool = extraTools.find((extraTool)=>extraTool.value === tool);
+            if (matchedTool?.action) await matchedTool.action();
+            if (matchedTool?.command) runCommand(matchedTool.command, distFolder);
+            continue;
+        }
         const toolFolder = node_path.join(packageRoot, `template-${tool}`);
         if ('eslint' === tool) {
-            const eslintTemplateName = mapESLintTemplate(templateName, {
+            const eslintTemplateName = mapESLintTemplate ? mapESLintTemplate(templateName, {
                 distFolder
-            });
+            }) : 'vanilla-ts';
             if (!eslintTemplateName) continue;
             const subFolder = node_path.join(toolFolder, eslintTemplateName);
             copyFolder({
@@ -1903,4 +2332,4 @@ function collectAgentsFiles(agentsMdSearchDirs) {
     }
     return agentsFiles;
 }
-export { BUILTIN_TOOLS, checkCancel, copyFolder, create, mergePackageJson, fe as multiselect, ve as select, he as text };
+export { BUILTIN_TOOLS, checkCancel, collectAgentsFiles, copyFolder, create, mergeAgentsFiles, mergePackageJson, fe as multiselect, ve as select, he as text };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-rstack",
-  "version": "1.7.10",
+  "version": "1.7.12",
   "description": "Create a new Rstack project",
   "repository": {
     "type": "git",
@@ -40,21 +40,26 @@
     ]
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.2",
+    "@biomejs/biome": "2.3.8",
     "@clack/prompts": "^0.11.0",
-    "@microsoft/api-extractor": "^7.53.3",
-    "@rslib/core": "0.17.0",
-    "@rstest/core": "0.6.1",
+    "@microsoft/api-extractor": "^7.55.1",
+    "@rslib/core": "0.18.2",
+    "@rstest/core": "0.6.8",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/fs-extra": "^11.0.4",
     "@types/minimist": "^1.2.5",
-    "@types/node": "24.9.2",
+    "@types/node": "24.10.1",
+    "cross-spawn": "^7.0.6",
     "deepmerge": "^4.3.1",
+    "fs-extra": "^11.3.2",
     "minimist": "^1.2.8",
     "picocolors": "^1.1.1",
-    "rslog": "^1.3.0",
+    "rimraf": "^6.1.2",
+    "rslog": "^1.3.2",
     "simple-git-hooks": "^2.13.1",
     "typescript": "^5.9.3"
   },
-  "packageManager": "pnpm@10.20.0",
+  "packageManager": "pnpm@10.24.0",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/template-biome/package.json

@@ -7,6 +7,6 @@
     "format": "biome format --write"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.2"
+    "@biomejs/biome": "2.3.8"
   }
 }

package/template-eslint/react-js/package.json

@@ -6,10 +6,10 @@
     "lint": "eslint ."
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.0",
-    "eslint": "^9.39.0",
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
-    "globals": "^16.4.0"
+    "globals": "^16.5.0"
   }
 }

package/template-eslint/react-ts/package.json

@@ -6,11 +6,11 @@
     "lint": "eslint ."
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.0",
-    "eslint": "^9.39.0",
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
-    "globals": "^16.4.0",
-    "typescript-eslint": "^8.46.2"
+    "globals": "^16.5.0",
+    "typescript-eslint": "^8.48.0"
   }
 }

package/template-eslint/svelte-js/package.json

@@ -6,9 +6,9 @@
     "lint": "eslint ."
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.0",
-    "eslint": "^9.39.0",
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
     "eslint-plugin-svelte": "^3.13.0",
-    "globals": "^16.4.0"
+    "globals": "^16.5.0"
   }
 }

package/template-eslint/svelte-ts/package.json

@@ -6,11 +6,11 @@
     "lint": "eslint ."
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.0",
-    "eslint": "^9.39.0",
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
     "eslint-plugin-svelte": "^3.13.0",
-    "globals": "^16.4.0",
-    "typescript-eslint": "^8.46.2"
+    "globals": "^16.5.0",
+    "typescript-eslint": "^8.48.0"
   },
   "type": "module"
 }

package/template-eslint/vanilla-js/package.json

@@ -6,8 +6,8 @@
     "lint": "eslint ."
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.0",
-    "eslint": "^9.39.0",
-    "globals": "^16.4.0"
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0"
   }
 }

package/template-eslint/vanilla-ts/package.json

@@ -6,9 +6,9 @@
     "lint": "eslint ."
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.0",
-    "eslint": "^9.39.0",
-    "globals": "^16.4.0",
-    "typescript-eslint": "^8.46.2"
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0",
+    "typescript-eslint": "^8.48.0"
   }
 }

package/template-eslint/vue-js/package.json

@@ -6,9 +6,9 @@
     "lint": "eslint ."
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.0",
-    "eslint": "^9.39.0",
-    "eslint-plugin-vue": "^10.5.1",
-    "globals": "^16.4.0"
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-vue": "^10.6.2",
+    "globals": "^16.5.0"
   }
 }

package/template-eslint/vue-ts/package.json

@@ -7,9 +7,9 @@
   },
   "devDependencies": {
     "@vue/eslint-config-typescript": "^14.6.0",
-    "eslint": "^9.39.0",
-    "eslint-plugin-vue": "^10.5.1",
-    "globals": "^16.4.0",
-    "typescript-eslint": "^8.46.2"
+    "eslint": "^9.39.1",
+    "eslint-plugin-vue": "^10.6.2",
+    "globals": "^16.5.0",
+    "typescript-eslint": "^8.48.0"
   }
 }

package/template-prettier/package.json

@@ -6,6 +6,6 @@
     "format": "prettier --write ."
   },
   "devDependencies": {
-    "prettier": "^3.6.2"
+    "prettier": "^3.7.3"
   }
 }