@lakutata/cli 3.0.0 → 3.1.0

package/dist/esm/lib/Migration.js

@@ -3,7 +3,7 @@ import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { camelCase } from 'lakutata/utils';
 import { LaunchEnvironment } from './Environment.js';
-import { spawnCommand } from './Processes.js';
+import { projectPackageManager, spawnCommand } from './Processes.js';
 /**
  * The files of a directory, none when it does not exist
  * @param directory
@@ -26,7 +26,7 @@ async function startApplication(application, env) {
     const base = Object.fromEntries(Object.entries(LaunchEnvironment).filter(([name]) => !name.toUpperCase().startsWith('MIGRATION_')));
     return await new Promise((resolve, reject) => {
         //The output of the application is the one of the command; the package managers are scripts on Windows
-        const child = spawnCommand('npm', ['run', application.script], {
+        const child = spawnCommand(projectPackageManager(application.directory), ['run', application.script], {
             cwd: application.directory,
             stdio: 'inherit',
             env: { ...base, ...env, ...(application.database ? { MIGRATION_DATABASE: application.database } : {}) }

package/dist/esm/lib/Output.js

@@ -36,5 +36,5 @@ export function warn(message) {
 export function table(rows, title) {
     const width = Math.max(...rows.map(([name]) => name.length));
     const lines = rows.map(([name, value]) => `  ${styled('blue', name.padEnd(width))}  ${value}`);
-    return `${title ? `${styled('bold', title)}\n` : ''}${lines.join('\n')}\n`;
+    return `${title ? `${styled('bold', title)}\n` : ''}${lines.map((line) => `${line}\n`).join('')}`;
 }

package/dist/esm/lib/Processes.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { LaunchEnvironment } from './Environment.js';
 /**
@@ -12,6 +13,67 @@ export function detectPackageManager() {
         return 'yarn';
     return 'npm';
 }
+/**
+ * Whether a directory is the root of a workspace: its package.json declares workspaces, or a pnpm-workspace.yaml is
+ * next to it
+ * @param directory
+ */
+function workspaceRoot(directory) {
+    const manifest = path.join(directory, 'package.json');
+    if (!existsSync(manifest))
+        return false;
+    if (existsSync(path.join(directory, 'pnpm-workspace.yaml')))
+        return true;
+    try {
+        const workspaces = JSON.parse(readFileSync(manifest, 'utf8')).workspaces;
+        return Array.isArray(workspaces) || Array.isArray(workspaces?.packages);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The package manager of a project: the packageManager field of its package.json ("pnpm@9.15.0"), else its lock file
+ * (pnpm-lock.yaml or pnpm-workspace.yaml, yarn.lock, package-lock.json), looked for from the directory up to the root
+ * of its workspace (the directory itself when it is in none); npm by default
+ * @param directory The directory of the project, or of one of the packages of its workspace.
+ */
+export function projectPackageManager(directory) {
+    const start = path.resolve(directory);
+    //The directories of the project: up to the nearest root of a workspace, the directory itself without one
+    const directories = [];
+    for (let current = start;; current = path.dirname(current)) {
+        directories.push(current);
+        if (workspaceRoot(current))
+            break;
+        if (path.dirname(current) === current) {
+            directories.splice(1);
+            break;
+        }
+    }
+    for (const current of directories) {
+        const manifest = path.join(current, 'package.json');
+        if (existsSync(manifest)) {
+            let declared;
+            try {
+                declared = JSON.parse(readFileSync(manifest, 'utf8')).packageManager;
+            }
+            catch {
+                declared = undefined;
+            }
+            const name = typeof declared === 'string' ? declared.split('@')[0] : undefined;
+            if (name === 'npm' || name === 'pnpm' || name === 'yarn')
+                return name;
+        }
+        if (existsSync(path.join(current, 'pnpm-lock.yaml')) || existsSync(path.join(current, 'pnpm-workspace.yaml')))
+            return 'pnpm';
+        if (existsSync(path.join(current, 'yarn.lock')))
+            return 'yarn';
+        if (existsSync(path.join(current, 'package-lock.json')))
+            return 'npm';
+    }
+    return 'npm';
+}
 /**
  * An argument of a command run by cmd.exe (Windows): quoted as the programs read their arguments
  * @param arg

package/dist/esm/lib/ProjectCreator.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { existsSync } from 'node:fs';
-import { cp, readdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import { cp, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { Component } from 'lakutata';
 import { Autoload, Inject, Singleton } from 'lakutata/decorator/di';
@@ -30,7 +30,7 @@ function isText(content) {
     return !content.subarray(0, 8000).includes(0);
 }
 /**
- * The files of a directory, relative to it
+ * The files of a directory, relative to it, without the directories which are not copied (SKIPPED)
  * @param directory
  * @param base
  */
@@ -38,6 +38,8 @@ async function listFiles(directory, base = directory) {
     const files = [];
     for (const entry of await readdir(directory, { withFileTypes: true })) {
         const target = path.join(directory, entry.name);
+        if (entry.isDirectory() && SKIPPED.includes(entry.name))
+            continue;
         if (entry.isDirectory())
             files.push(...await listFiles(target, base));
         else if (entry.isFile())
@@ -74,22 +76,25 @@ let ProjectCreator = class ProjectCreator extends Component {
             throw new Error(`The directory ${directory} is not empty (--init creates the project in an existing directory)`);
     }
     /**
-     * Copy the files of a template into the directory of the project
+     * Copy the files of a template into the directory of the project; the files the directory has already (--init)
+     * are kept as they are, the ones of the template not copied
      * @param template
      * @param directory
-     * @return the paths of the files of the project, relative to its directory
+     * @param kept the files of the directory kept, relative to it
+     * @return the paths of the files copied, relative to the directory
      */
-    async copy(template, directory) {
-        await cp(template.root, directory, {
-            recursive: true,
-            filter: (source) => !SKIPPED.includes(path.basename(source))
-        });
+    async copy(template, directory, kept) {
         const files = [];
-        for (const file of await listFiles(directory)) {
+        for (const file of await listFiles(template.root)) {
             //"_gitignore" becomes ".gitignore"
             const renamed = projectPath(file);
-            if (renamed !== file)
-                await rename(path.join(directory, file), path.join(directory, renamed));
+            const target = path.join(directory, renamed);
+            if (existsSync(target)) {
+                kept.push(renamed);
+                continue;
+            }
+            await mkdir(path.dirname(target), { recursive: true });
+            await cp(path.join(template.root, file), target);
             files.push(renamed);
         }
         return files;
@@ -129,15 +134,20 @@ let ProjectCreator = class ProjectCreator extends Component {
      */
     async create(plan, template) {
         await this.checkDirectory(plan.directory, plan.init);
-        const files = await this.copy(template, plan.directory);
-        for (const feature of plan.features) {
+        for (const feature of plan.features)
             if (!(feature in template.features))
                 throw new Error(`The template has no feature ${feature}`);
+        //Only the files written are filled: the other files of the directory (--init) are not the template's
+        const kept = [];
+        const files = await this.copy(template, plan.directory, kept);
+        for (const feature of plan.features) {
             const directory = path.join(template.featuresDirectory, feature);
             if (existsSync(directory))
-                files.push(...await applyFeatureFiles(directory, plan.directory));
+                files.push(...await applyFeatureFiles(directory, plan.directory, new Set(files), kept));
         }
         done(`Template ${template.label} copied (${files.length} files${plan.features.length ? `, with ${plan.features.join(', ')}` : ''})`);
+        if (kept.length)
+            warn(`The files of the directory are kept: ${[...new Set(kept)].sort().join(', ')}. Their versions in the template are not copied: merge what you need of them by hand (the scripts and the dependencies of package.json)`);
         await this.fill(plan.directory, files, {
             $APP_NAME: plan.name,
             $APP_ID: plan.id,

package/dist/esm/lib/Registry.js

@@ -44,6 +44,13 @@ export function compareVersions(a, b) {
     }
     return 0;
 }
+/**
+ * The highest of versions, the prereleases included (the strings which are not versions left out)
+ * @param versions
+ */
+export function highestVersion(versions) {
+    return versions.filter((version) => !!versionParts(version)).sort(compareVersions).at(-1);
+}
 /**
  * The newest version of a major version (the prereleases only when the major version has no release)
  * @param versions

package/dist/esm/lib/TemplateFeatures.js

@@ -72,13 +72,21 @@ async function listFiles(directory, base = directory) {
  * (the scripts of package.json, the options of tsconfig.json)
  * @param featureDirectory
  * @param project
+ * @param written the files the creation of the project wrote: the other files of the directory (--init) are kept as
+ * they are, added to kept
+ * @param kept
  * @return the files added to the project, relative to it
  */
-export async function applyFeatureFiles(featureDirectory, project) {
+export async function applyFeatureFiles(featureDirectory, project, written, kept = []) {
     const added = [];
     for (const file of await listFiles(featureDirectory)) {
         const relative = projectPath(file);
         const target = path.join(project, relative);
+        //A file the directory had before the project was created (--init) is kept as it is
+        if (written && existsSync(target) && !written.has(relative)) {
+            kept.push(relative);
+            continue;
+        }
         await mkdir(path.dirname(target), { recursive: true });
         if (existsSync(target) && file.endsWith('.json')) {
             const merged = mergeJson(JSON.parse(await readFile(target, 'utf8')), JSON.parse(await readFile(path.join(featureDirectory, file), 'utf8')));

package/dist/esm/lib/native/NativeProject.js

@@ -73,6 +73,8 @@ function scopeOf(change, library) {
     }
     if (library && change.platform && library.platform !== 'unix' && change.platform !== library.platform)
         throw new Error(`${library.file} is a library of ${library.platform}, not of ${change.platform}`);
+    if (change.pkgConfig && change.platform === 'win')
+        throw new Error('pkg-config is not on Windows: link the library by its file (deps/lib/foo.lib) or by its name');
     if (change.platform)
         return change.platform;
     if (library)
@@ -268,7 +270,8 @@ async function changeCMake(directory, change, library, scope) {
     else if (library?.kind === 'dynamic') {
         commands([
             link(source(library.platform === 'win' ? importLibrary(directory, library) : library.file)),
-            ...(library.platform === 'win' ? [] : [['set_target_properties', name, 'PROPERTIES', 'BUILD_RPATH', library.platform === 'mac' ? '@loader_path' : '$ORIGIN']]),
+            //The rpath of the addon is its directory only, not the directories of the libraries on the machine building it
+            ...(library.platform === 'win' ? [] : [['set_target_properties', name, 'PROPERTIES', 'BUILD_WITH_INSTALL_RPATH', 'ON', 'INSTALL_RPATH', library.platform === 'mac' ? '@loader_path' : '$ORIGIN']]),
             //Copied next to the addon, found there at run time
             ['add_custom_command', 'TARGET', name, 'POST_BUILD', 'COMMAND', '${CMAKE_COMMAND}', '-E', 'copy_if_different', source(library.file), `$<TARGET_FILE_DIR:${name}>`]
         ]);
@@ -315,7 +318,9 @@ async function changeRust(directory, change, library, scope) {
     else if (library?.kind === 'dynamic') {
         if (library.platform === 'win')
             importLibrary(directory, library);
-        directives.push(`rustc-link-search=native=${path.posix.dirname(library.file)}`, `rustc-link-lib=dylib=${library.name}`);
+        //A versioned library (libfoo.so.1) by its file name: -lfoo would find libfoo.so
+        const base = path.posix.basename(library.file);
+        directives.push(`rustc-link-search=native=${path.posix.dirname(library.file)}`, /\.so\.\d/.test(base) ? `rustc-link-lib=dylib:+verbatim=${base}` : `rustc-link-lib=dylib=${library.name}`);
         if (library.platform === 'mac')
             directives.push('rustc-cdylib-link-arg=-Wl,-rpath,@loader_path');
         if (library.platform === 'linux')
@@ -333,13 +338,15 @@ async function changeRust(directory, change, library, scope) {
         files.push('.cargo/config.toml');
     }
     if (library?.kind === 'dynamic') {
-        //Copied next to the addon after its build (when it is built on the platform of the library)
+        //Copied next to the addon by its build (when it is built on the platform of the library), whatever the package
+        //manager running it (pnpm runs no post scripts by default)
         const manifestFile = path.join(directory, 'package.json');
         const manifest = JSON.parse(await readFile(manifestFile, 'utf8'));
         const copy = `node -e "const fs=require('node:fs');if(fs.existsSync('${library.file}'))fs.copyFileSync('${library.file}','build/Release/${path.posix.basename(library.file)}')"`;
         const scripts = manifest.scripts ?? {};
-        if (!(scripts['postbuild:native'] ?? '').includes(copy)) {
-            scripts['postbuild:native'] = scripts['postbuild:native'] ? `${scripts['postbuild:native']} && ${copy}` : copy;
+        const build = scripts['build:native'] ?? 'napi build --release --output-dir build/Release';
+        if (!build.includes(copy) && !(scripts['postbuild:native'] ?? '').includes(copy)) {
+            scripts['build:native'] = `${build} && ${copy}`;
             manifest.scripts = scripts;
             await writeFile(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`);
             files.push('package.json');
@@ -360,6 +367,10 @@ export async function changeNative(directory, change) {
         throw new Error('The crates are the libraries of the Rust addons');
     const library = change.action === 'link' && !change.crate && !change.pkgConfig && !change.framework ? libraryOfFile(directory, change.value) : undefined;
     const scope = scopeOf(change, library);
+    //The headers of the package, or of the system (an absolute directory): the addon is built where it is installed
+    if (change.action === 'include' && !path.isAbsolute(change.value) && path.relative(directory, path.resolve(directory, change.value)).startsWith('..')) {
+        throw new Error(`${change.value} is not in the package: the addon is built where the package is installed (give a directory of the package, or an absolute directory of the system)`);
+    }
     const files = build === 'gyp'
         ? await changeGyp(directory, change, library, scope)
         : build === 'cmake' ? await changeCMake(directory, change, library, scope) : await changeRust(directory, change, library, scope);

package/dist/esm/lib/workspace/Run.js

@@ -1,19 +1,20 @@
 import os from 'node:os';
 import { LaunchEnvironment } from '../Environment.js';
-import { spawnCommand } from '../Processes.js';
+import { projectPackageManager, spawnCommand } from '../Processes.js';
 import { styled, warn } from '../Output.js';
 import { matchName } from './Workspace.js';
 const COLORS = ['cyan', 'magenta', 'yellow', 'green', 'blue', 'red'];
 /**
- * Run a script of a package, its output prefixed with the name of the package
+ * Run a script of a package with the package manager of the workspace, its output prefixed with the name of the package
+ * @param packageManager
  * @param pkg
  * @param script
  * @param args
  * @param prefix
  */
-function runPackageScript(pkg, script, args, prefix) {
+function runPackageScript(packageManager, pkg, script, args, prefix) {
     return new Promise((resolve) => {
-        const child = spawnCommand('npm', ['run', script, ...(args.length ? ['--', ...args] : [])], { cwd: pkg.directory, env: LaunchEnvironment });
+        const child = spawnCommand(packageManager, ['run', script, ...(args.length ? ['--', ...args] : [])], { cwd: pkg.directory, env: LaunchEnvironment });
         const forward = (stream, target) => {
             let pending = '';
             stream.on('data', (chunk) => {
@@ -45,7 +46,10 @@ function runPackageScript(pkg, script, args, prefix) {
  * @param options
  */
 export async function runScript(workspace, script, options = {}) {
+    const packageManager = projectPackageManager(workspace.root);
     const inScope = (pkg) => !options.scope?.length || options.scope.some((pattern) => matchName(pkg.name, pattern));
+    if (options.scope?.length && !workspace.packages.some(inScope))
+        throw new Error(`The workspace has no package matching ${options.scope.join(', ')} (${workspace.packages.map((pkg) => pkg.name).join(', ')})`);
     const selected = workspace.packages.filter((pkg) => inScope(pkg) && !!pkg.scripts[script]);
     const skipped = workspace.packages.filter((pkg) => inScope(pkg) && !pkg.scripts[script]).map((pkg) => pkg.name);
     const selectedNames = new Set(selected.map((pkg) => pkg.name));
@@ -81,7 +85,7 @@ export async function runScript(workspace, script, options = {}) {
                 if (![...waitsFor.get(pkg.name)].every((name) => done.has(name)))
                     continue;
                 const prefix = styled(COLORS[selected.indexOf(pkg) % COLORS.length], `${pkg.name.padEnd(width)} │`);
-                running.set(pkg.name, runPackageScript(pkg, script, options.args ?? [], prefix).then((code) => {
+                running.set(pkg.name, runPackageScript(packageManager, pkg, script, options.args ?? [], prefix).then((code) => {
                     running.delete(pkg.name);
                     if (code === 0) {
                         done.add(pkg.name);

package/dist/esm/lib/workspace/Version.js

@@ -4,6 +4,13 @@ import { runCommand } from '../Processes.js';
 import { warn } from '../Output.js';
 import { DEPENDENCY_FIELDS } from './Workspace.js';
 const VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+/**
+ * Whether a string is a version (1.2.3, 1.3.0-beta.0)
+ * @param version
+ */
+export function isVersion(version) {
+    return VERSION.test(version);
+}
 /**
  * The next version
  * @param current
@@ -81,6 +88,19 @@ export function planVersion(workspace, bump, preid) {
  * @param options
  */
 export async function applyVersion(workspace, plan, options = {}) {
+    const git = async (args) => {
+        const result = await runCommand('git', args, workspace.root);
+        if (result.code !== 0)
+            throw new Error(`git ${args[0]} failed: ${result.output.trim()}`);
+        return result.output;
+    };
+    //Checked before a file is changed: a repository, and a tag which does not exist yet
+    if (options.git) {
+        if ((await runCommand('git', ['rev-parse', '--is-inside-work-tree'], workspace.root).catch((error) => ({ code: 1, output: error.message }))).code !== 0)
+            throw new Error(`${workspace.root} is not in a git repository: --git commits the version there`);
+        if ((await runCommand('git', ['rev-parse', '-q', '--verify', `refs/tags/v${plan.to}`], workspace.root)).code === 0)
+            throw new Error(`The tag v${plan.to} exists already`);
+    }
     const names = new Set(workspace.packages.map((pkg) => pkg.name));
     const changed = [];
     for (const pkg of workspace.packages) {
@@ -94,8 +114,8 @@ export async function applyVersion(workspace, plan, options = {}) {
         }
         changed.push(pkg.manifest);
     }
-    //The version of the workspace is kept by lerna.json when it has one, by the root package.json otherwise
-    if (workspace.lerna) {
+    //The version of the workspace is kept by lerna.json when it gives one, by the root package.json otherwise
+    if (workspace.lerna?.data.version !== undefined) {
         workspace.lerna.data.version = plan.to;
         changed.push(workspace.lerna);
     }
@@ -131,13 +151,9 @@ export async function applyVersion(workspace, plan, options = {}) {
         warn('yarn.lock is not updated: run yarn install');
     }
     if (options.git) {
-        const git = async (args) => {
-            const result = await runCommand('git', args, workspace.root);
-            if (result.code !== 0)
-                throw new Error(`git ${args[0]} failed: ${result.output.trim()}`);
-        };
+        //Only the files of the version are committed, the changes staged before kept staged
         await git(['add', ...files]);
-        await git(['commit', '-m', `v${plan.to}`]);
+        await git(['commit', '-m', `v${plan.to}`, '--', ...files]);
         await git(['tag', `v${plan.to}`]);
     }
     return files;

package/dist/esm/lib/workspace/Workspace.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { readdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { newestVersion } from '../Registry.js';
+import { highestVersion } from '../Registry.js';
 /**
  * The fields of the dependencies of a package
  */
@@ -79,14 +79,25 @@ async function expandPattern(root, pattern) {
     return walk(root, 0);
 }
 /**
- * The patterns of the packages of a pnpm workspace
+ * The patterns of the packages of a pnpm workspace: a block list (one "- 'packages/*'" per line) or a flow list
+ * (packages: ['packages/*', 'apps/*'], on one line or on several)
  * @param file
  */
 async function pnpmPatterns(file) {
     const patterns = [];
+    const text = await readFile(file, 'utf8');
+    const flow = /^packages:\s*\[([^\]]*)\]/m.exec(text);
+    if (flow) {
+        for (const item of flow[1].replace(/#.*$/gm, '').split(',')) {
+            const pattern = item.trim().replace(/^(['"])(.*)\1$/, '$2');
+            if (pattern)
+                patterns.push(pattern);
+        }
+        return patterns;
+    }
     let inPackages = false;
-    for (const line of (await readFile(file, 'utf8')).split('\n')) {
-        if (/^packages:\s*$/.test(line)) {
+    for (const line of text.split('\n')) {
+        if (/^packages:\s*(#.*)?$/.test(line)) {
             inPackages = true;
             continue;
         }
@@ -104,11 +115,25 @@ async function pnpmPatterns(file) {
  * A workspace: its root, its packages and their fixed version
  */
 export class Workspace {
-    constructor(root, manifest, packages, lerna) {
+    constructor(root, manifest, packages, lerna, patterns = []) {
         this.root = root;
         this.manifest = manifest;
         this.packages = packages;
         this.lerna = lerna;
+        this.patterns = patterns;
+    }
+    /**
+     * The directory where new packages go: the one of the first pattern of the workspace of the form <directory>/*
+     * (packages/* when it has it), undefined when its packages are all named one by one
+     */
+    get packagesDirectory() {
+        const directories = this.patterns
+            .filter((pattern) => !pattern.startsWith('!'))
+            .map((pattern) => pattern.replace(/^\.\//, ''))
+            .filter((pattern) => /^[^*?{}[\]!]+\/\*$/.test(pattern))
+            .map((pattern) => pattern.slice(0, -2));
+        const directory = directories.includes('packages') ? 'packages' : directories[0];
+        return directory === undefined ? undefined : path.join(this.root, directory);
     }
     /**
      * The workspace of a directory: the nearest directory declaring workspaces
@@ -171,7 +196,7 @@ export class Workspace {
             pkg.dependencies = [...dependencies];
         }
         const lernaFile = path.join(root, 'lerna.json');
-        return new Workspace(root, manifest, packages, existsSync(lernaFile) ? await JSONFile.read(lernaFile) : undefined);
+        return new Workspace(root, manifest, packages, existsSync(lernaFile) ? await JSONFile.read(lernaFile) : undefined, patterns);
     }
     /**
      * A package by name
@@ -224,8 +249,9 @@ export class Workspace {
     }
     /**
      * The fixed version of the workspace: the one of lerna.json, of the root package.json, or the highest of the packages
+     * (a prerelease above the releases included)
      */
     get version() {
-        return this.lerna?.data.version ?? this.manifest.data.version ?? newestVersion(this.packages.map((pkg) => pkg.version).filter((version) => !!version));
+        return this.lerna?.data.version ?? this.manifest.data.version ?? highestVersion(this.packages.map((pkg) => pkg.version).filter((version) => !!version));
     }
 }

package/dist/esm/locales/zh-CN.json

@@ -14,7 +14,7 @@
                     "author": "应用的作者",
                     "license": "应用的许可证",
                     "packageManager": "安装依赖使用的包管理器，默认是运行本工具的那个（none 表示不安装）",
-                    "with": "启用模板的可选功能，多个用逗号分隔（lakutata templates 会列出）：i18n",
+                    "with": "启用模板的可选功能，多个用逗号分隔（lakutata templates 会列出）：i18n、installer",
                     "git": "初始化 git 仓库",
                     "yes": "不经确认直接创建项目"
                 }
@@ -58,9 +58,9 @@
                 }
             },
             "add": {
-                "description": "向工作区添加一个包（packages/<名称>）：TypeScript 包，或用 --native [gyp|cmake|rust] 添加原生插件",
+                "description": "向工作区添加一个包（放在工作区的包目录中：packages/<名称>）：TypeScript 包，或用 --native [gyp|cmake|rust] 添加原生插件",
                 "arguments": {
-                    "name": "包的名称（工作区的 packages/<名称>）"
+                    "name": "包的名称（它在工作区包目录中的目录：packages/<名称>）"
                 },
                 "options": {
                     "native": "原生插件，按构建系统：gyp（C++，node-gyp，默认）、cmake（C++，cmake-js）或 rust（napi-rs）",
@@ -114,7 +114,7 @@
                     "script": "构建并启动应用的包脚本（generate、run、revert、show）",
                     "package": "应用所在的工作区包（默认是当前目录）",
                     "database": "数据库：其 Database 组件或提供者的名称（默认全部；应用有多个数据库时，回滚必须指定）",
-                    "transaction": "执行或回滚迁移的事务方式：all（一个事务，默认）、each（每个迁移一个）或 none",
+                    "transaction": "执行或回滚迁移的事务方式：all（所有迁移一个事务）、each（每个迁移一个）或 none；默认取数据库的 migrationsTransactionMode，没有时为 all",
                     "fake": "只标记迁移为已执行或已回滚，不实际执行"
                 }
             },

package/dist/esm/locales/zh-TW.json

@@ -14,7 +14,7 @@
                     "author": "應用程式的作者",
                     "license": "應用程式的授權條款",
                     "packageManager": "安裝相依套件使用的套件管理器，預設是執行本工具的那個（none 表示不安裝）",
-                    "with": "啟用範本的可選功能，多個用逗號分隔（lakutata templates 會列出）：i18n",
+                    "with": "啟用範本的可選功能，多個用逗號分隔（lakutata templates 會列出）：i18n、installer",
                     "git": "初始化 git 儲存庫",
                     "yes": "不經確認直接建立專案"
                 }
@@ -58,9 +58,9 @@
                 }
             },
             "add": {
-                "description": "向工作區新增一個套件（packages/<名稱>）：TypeScript 套件，或用 --native [gyp|cmake|rust] 新增原生外掛",
+                "description": "向工作區新增一個套件（放在工作區的套件目錄中：packages/<名稱>）：TypeScript 套件，或用 --native [gyp|cmake|rust] 新增原生外掛",
                 "arguments": {
-                    "name": "套件的名稱（工作區的 packages/<名稱>）"
+                    "name": "套件的名稱（它在工作區套件目錄中的目錄：packages/<名稱>）"
                 },
                 "options": {
                     "native": "原生外掛，依建置系統：gyp（C++，node-gyp，預設）、cmake（C++，cmake-js）或 rust（napi-rs）",
@@ -114,7 +114,7 @@
                     "script": "建置並啟動應用程式的套件指令碼（generate、run、revert、show）",
                     "package": "應用程式所在的工作區套件（預設是目前目錄）",
                     "database": "資料庫：其 Database 元件或提供者的名稱（預設全部；應用程式有多個資料庫時，復原必須指定）",
-                    "transaction": "執行或復原遷移的交易方式：all（一個交易，預設）、each（每個遷移一個）或 none",
+                    "transaction": "執行或復原遷移的交易方式：all（所有遷移一個交易）、each（每個遷移一個）或 none；預設取資料庫的 migrationsTransactionMode，沒有時為 all",
                     "fake": "只標記遷移為已執行或已復原，不實際執行"
                 }
             },

package/package.json

@@ -1,7 +1,30 @@
 {
   "name": "@lakutata/cli",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "The command line tool of the lakutata framework: create the projects from the templates, run and version the packages of the workspaces, bundle the applications and make their executables (with @lakutata/builder).",
+  "keywords": [
+    "lakutata",
+    "cli",
+    "scaffolding",
+    "templates",
+    "monorepo",
+    "workspaces",
+    "bundle",
+    "executable",
+    "installer",
+    "typescript"
+  ],
+  "homepage": "https://lakutata.com/packages/cli",
+  "bugs": {
+    "url": "https://github.com/lakutata/lakutata/issues",
+    "email": "admin@lakutata.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lakutata/lakutata.git",
+    "directory": "packages/cli"
+  },
+  "author": "alex.ma",
   "type": "module",
   "bin": {
     "lakutata": "./dist/esm/CLIApp.js"
@@ -16,10 +39,10 @@
   "dependencies": {
     "@inquirer/prompts": "^8.7.2",
     "commander": "^15.0.0",
-    "lakutata": "3.0.0"
+    "lakutata": "3.1.0"
   },
   "peerDependencies": {
-    "@lakutata/builder": "3.0.0"
+    "@lakutata/builder": "3.1.0"
   },
   "peerDependenciesMeta": {
     "@lakutata/builder": {
@@ -27,10 +50,10 @@
     }
   },
   "devDependencies": {
-    "@lakutata/builder": "3.0.0"
+    "@lakutata/builder": "3.1.0"
   },
   "engines": {
-    "node": ">=22.12"
+    "node": "^22.13.0 || >=24.11.0"
   },
   "license": "MIT",
   "files": [