@lakutata/cli 2.17.0 → 3.0.0-beta.0

package/dist/esm/controllers/CommandLineController.js

@@ -0,0 +1,180 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import path from 'node:path';
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { Inject } from 'lakutata/decorator/di';
+import { Translator } from 'lakutata/com/i18n';
+import { CreateProjectDTO } from '../dtos/CreateProjectDTO.js';
+import { ListTemplatesDTO } from '../dtos/ListTemplatesDTO.js';
+import { CleanDTO } from '../dtos/CleanDTO.js';
+import { clean, outputDirectories } from '../lib/Clean.js';
+import { TemplateCatalog } from '../lib/TemplateCatalog.js';
+import { ProjectCreator } from '../lib/ProjectCreator.js';
+import { detectPackageManager } from '../lib/Processes.js';
+import { done, styled, table } from '../lib/Output.js';
+import { frameworkVersion, latestVersion, projectFrameworkVersion, toolPackage } from '../lib/Versions.js';
+import { localize } from '../lib/Language.js';
+/**
+ * Whether the tool runs in a terminal, where it asks the questions
+ */
+function interactive() {
+    return !!process.stdin.isTTY && !!process.stdout.isTTY;
+}
+export class CommandLineController extends Controller {
+    async create(input) {
+        const template = await this.catalog.resolve(input.template);
+        const directory = input.init ? path.resolve(input.path) : path.resolve(input.path, input.name);
+        await this.creator.checkDirectory(directory, input.init);
+        const prepared = await this.creator.prepare(template);
+        try {
+            return await this.createFrom(input, template, prepared, directory);
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    }
+    /**
+     * The features of the template enabled: the ones of --with, or the ones chosen in a terminal
+     * @param input
+     * @param template
+     */
+    async features(input, template) {
+        const available = Object.keys(template.features);
+        if (input.with !== undefined) {
+            const features = [...new Set(input.with.split(',').map((feature) => feature.trim()).filter(Boolean))];
+            const unknown = features.filter((feature) => !available.includes(feature));
+            if (unknown.length)
+                throw new Error(`The template has no feature ${unknown.join(', ')} (${available.length ? `its features: ${available.join(', ')}` : 'it has no feature'})`);
+            return features;
+        }
+        if (!available.length || !interactive() || input.yes)
+            return [];
+        const { checkbox } = await import('@inquirer/prompts');
+        return await checkbox({
+            message: localize(this.i18n, 'prompts.features', 'The features of the project'),
+            choices: available.map((feature) => ({ name: `${feature}: ${template.features[feature]}`, value: feature }))
+        });
+    }
+    /**
+     * Create a project from its template
+     * @param input
+     * @param template
+     * @param prepared
+     * @param directory
+     */
+    async createFrom(input, template, prepared, directory) {
+        const features = await this.features(input, prepared);
+        const plan = {
+            name: input.name,
+            id: input.id ?? input.name.toLowerCase(),
+            description: input.description,
+            author: input.author,
+            license: input.license,
+            template: template,
+            directory: directory,
+            init: input.init,
+            packageManager: input.packageManager ?? detectPackageManager(),
+            git: input.git,
+            features: features
+        };
+        const say = (key, text, params) => localize(this.i18n, key, text, params);
+        process.stdout.write(table([
+            [say('plan.name', 'Name'), plan.name],
+            [say('plan.id', 'ID'), plan.id],
+            [say('plan.description', 'Description'), plan.description || '-'],
+            [say('plan.author', 'Author'), plan.author || '-'],
+            [say('plan.license', 'License'), plan.license],
+            [say('plan.template', 'Template'), input.template],
+            ...(Object.keys(prepared.features).length ? [[say('plan.features', 'Features'), features.length ? features.join(', ') : say('plan.none', 'none')]] : []),
+            [say('plan.directory', 'Directory'), directory],
+            [say('plan.dependencies', 'Dependencies'), plan.packageManager === 'none' ? say('plan.notInstalled', 'not installed') : say('plan.installed', 'installed with {manager}', { manager: plan.packageManager })],
+            [say('plan.git', 'Git'), plan.git ? say('plan.initialized', 'initialized') : say('plan.notInitialized', 'not initialized')]
+        ], say('plan.title', 'The project')));
+        if (interactive() && !input.yes) {
+            const { confirm } = await import('@inquirer/prompts');
+            if (!await confirm({ message: say('prompts.create', 'Create the project?'), default: true }))
+                return say('prompts.notCreated', 'The project is not created');
+        }
+        await this.creator.create(plan, prepared);
+        //The path of the project from the current directory, or its absolute path when it is elsewhere
+        const relative = path.relative(process.cwd(), directory);
+        const location = !relative || relative.startsWith('..') ? directory : relative;
+        return `\n${styled('green', 'The project is created')} in ${directory}\n${relative ? `\n  cd ${location}\n` : ''}`;
+    }
+    async templates(input) {
+        const templates = await this.catalog.list(input.refresh);
+        return `${table(templates.map((template) => [template.name, `${template.description}${template.features?.length ? ` (features: ${template.features.join(', ')})` : ''}`]), 'The templates (lakutata create --template <name>)')}
+Other templates: --template npm:<package>, github:<owner>/<repo>, or a directory
+The features of a template are enabled by lakutata create --with <features>
+`;
+    }
+    async clean(input) {
+        const directory = process.cwd();
+        const paths = input.paths?.length ? input.paths : await outputDirectories(directory);
+        const result = await clean(directory, paths);
+        done(result.removed.length ? `Removed ${result.removed.join(', ')}` : `Nothing to remove (${result.missing.join(', ')})`);
+        return undefined;
+    }
+    async info() {
+        const tool = toolPackage();
+        const [latestTool, latestFramework] = await Promise.all([latestVersion(tool.name), latestVersion('lakutata')]);
+        const project = await projectFrameworkVersion(process.cwd());
+        const latest = (version) => version ? ` (latest ${version})` : '';
+        const rows = [
+            ['Tool', `${tool.name} ${tool.version}${latest(latestTool)}`],
+            ['Framework', `lakutata ${frameworkVersion()}${latest(latestFramework)}`],
+            ['Node.js', `${process.version} (${process.platform} ${process.arch})`]
+        ];
+        if (project)
+            rows.push(['Project', `${project.project}: lakutata ${project.installed ?? 'not installed'} (${project.declared})`]);
+        return table(rows);
+    }
+}
+__decorate([
+    Inject(TemplateCatalog),
+    __metadata("design:type", TemplateCatalog)
+], CommandLineController.prototype, "catalog", void 0);
+__decorate([
+    Inject(ProjectCreator),
+    __metadata("design:type", ProjectCreator
+    /**
+     * The prompts in the language of the user
+     */
+    )
+], CommandLineController.prototype, "creator", void 0);
+__decorate([
+    Inject(Translator),
+    __metadata("design:type", Translator)
+], CommandLineController.prototype, "i18n", void 0);
+__decorate([
+    CLIAction('create', CreateProjectDTO, { description: 'Create a lakutata project from a template' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateProjectDTO]),
+    __metadata("design:returntype", Promise)
+], CommandLineController.prototype, "create", null);
+__decorate([
+    CLIAction('templates', ListTemplatesDTO, { description: 'List the project templates' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ListTemplatesDTO]),
+    __metadata("design:returntype", Promise)
+], CommandLineController.prototype, "templates", null);
+__decorate([
+    CLIAction('clean [paths...]', CleanDTO, { description: 'Remove paths of the package of the current directory, on every platform (the outDir of its tsconfig.json by default)' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CleanDTO]),
+    __metadata("design:returntype", Promise)
+], CommandLineController.prototype, "clean", null);
+__decorate([
+    CLIAction('info', { description: 'Show the versions of the tool and of the framework' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CommandLineController.prototype, "info", null);

package/dist/esm/controllers/I18nController.js

@@ -0,0 +1,67 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { checkCatalogs, generateMessageTypes, loadCatalogs } from 'lakutata/com/i18n';
+import { I18nDTO } from '../dtos/I18nDTO.js';
+import { done, styled, warn } from '../lib/Output.js';
+import { addLocale } from '../lib/I18n.js';
+/**
+ * The commands of the messages of the languages (lakutata/com/i18n)
+ */
+export class I18nController extends Controller {
+    async i18n(input) {
+        const directories = input.dir.split(',').map((directory) => path.resolve(directory.trim())).filter(Boolean);
+        const relative = (file) => path.relative(process.cwd(), file) || '.';
+        switch (input.action) {
+            case 'check': {
+                const catalogs = await loadCatalogs(directories);
+                const issues = checkCatalogs(catalogs, input.default);
+                for (const issue of issues) {
+                    const where = issue.key ? `${issue.locale} ${issue.key}` : issue.locale;
+                    process.stdout.write(`${issue.level === 'error' ? styled('red', '✖') : styled('yellow', '!')} ${styled('bold', where)}: ${issue.message}\n`);
+                }
+                const errors = issues.filter((issue) => issue.level === 'error').length;
+                const warnings = issues.length - errors;
+                const summary = `${catalogs.size} language${catalogs.size === 1 ? '' : 's'} (${[...catalogs.keys()].sort().join(', ')}), ${errors} error${errors === 1 ? '' : 's'}, ${warnings} warning${warnings === 1 ? '' : 's'}`;
+                if (errors || (input.strict && warnings))
+                    throw new Error(`The messages have problems: ${summary}`);
+                done(`Messages checked: ${summary}`);
+                return undefined;
+            }
+            case 'types': {
+                const declaration = generateMessageTypes(await loadCatalogs(directories), input.default, input.module);
+                const file = path.resolve(input.out);
+                await mkdir(path.dirname(file), { recursive: true });
+                await writeFile(file, declaration);
+                done(`Types of the messages of ${input.default} declared: ${relative(file)}`);
+                return undefined;
+            }
+            case 'add': {
+                if (!input.locale)
+                    throw new Error('The language is required: lakutata i18n add <locale>');
+                if (directories.length !== 1)
+                    throw new Error('A language is added to one directory (--dir)');
+                const files = await addLocale(directories[0], input.locale, input.default);
+                done(`Messages of ${input.locale} added: ${files.map(relative).join(', ')}`);
+                warn(`They are the messages of ${input.default}: translate them (lakutata i18n check tells the ones which are not)`);
+                return undefined;
+            }
+        }
+    }
+}
+__decorate([
+    CLIAction('i18n <action> [locale]', I18nDTO, { description: 'Check the messages of the languages, declare the types of their keys, or add a language' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [I18nDTO]),
+    __metadata("design:returntype", Promise)
+], I18nController.prototype, "i18n", null);

package/dist/esm/controllers/MigrationController.js

@@ -0,0 +1,66 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import path from 'node:path';
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { MigrationDTO } from '../dtos/MigrationDTO.js';
+import { done } from '../lib/Output.js';
+import { createMigration, executeMigrations, generateMigrations } from '../lib/Migration.js';
+import { Workspace } from '../lib/workspace/Workspace.js';
+/**
+ * The commands of the migrations of the databases of the application
+ */
+export class MigrationController extends Controller {
+    async migration(input) {
+        let directory = process.cwd();
+        if (input.package) {
+            const workspace = await Workspace.find();
+            const pkg = workspace.packages.find((candidate) => candidate.name === input.package);
+            if (!pkg)
+                throw new Error(`The workspace has no package ${input.package} (${workspace.packages.map((candidate) => candidate.name).join(', ')})`);
+            directory = pkg.directory;
+        }
+        const relative = (file) => path.relative(process.cwd(), path.join(directory, file));
+        switch (input.action) {
+            case 'create': {
+                if (!input.name)
+                    throw new Error('The name of the migration is required: lakutata migration create <name>');
+                const file = await createMigration({ directory: directory, dir: input.dir, name: input.name });
+                done(`Migration created: ${relative(file)} (given to the migrations of the options of its database)`);
+                return undefined;
+            }
+            case 'generate': {
+                const result = await generateMigrations({ directory: directory, dir: input.dir, script: input.script, database: input.database });
+                if (result.files.length) {
+                    done(`Migrations generated: ${result.files.map(relative).join(', ')}`);
+                    return undefined;
+                }
+                //The application tells why (no change of the schema, the failure)
+                if (result.code !== 0)
+                    throw new Error(`No migration generated (the application exited with the code ${result.code})`);
+                done('No migration generated: the application has no Database component or provider');
+                return undefined;
+            }
+            default: {
+                //The application tells what it did
+                const code = await executeMigrations({ directory: directory, script: input.script, database: input.database, action: input.action, transaction: input.transaction, fake: input.fake });
+                if (code !== 0)
+                    throw new Error(`The command ${input.action} of the migrations failed (the application exited with the code ${code})`);
+                return undefined;
+            }
+        }
+    }
+}
+__decorate([
+    CLIAction('migration <action> [name]', MigrationDTO, { description: 'Generate, create, run, revert or show the migrations of the databases of the application' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MigrationDTO]),
+    __metadata("design:returntype", Promise)
+], MigrationController.prototype, "migration", null);

package/dist/esm/controllers/NativeController.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { NativeDTO } from '../dtos/NativeDTO.js';
+import { done, warn } from '../lib/Output.js';
+import { changeNative } from '../lib/native/NativeProject.js';
+/**
+ * The commands of the native addons: the libraries, the headers and the macros of their builds
+ */
+export class NativeController extends Controller {
+    async native(input) {
+        const result = await changeNative(process.cwd(), {
+            action: input.action,
+            value: input.value,
+            platform: input.platform,
+            pkgConfig: input.pkgConfig,
+            framework: input.framework,
+            crate: input.crate,
+            target: input.target
+        });
+        const what = { link: 'Linked', include: 'Included', define: 'Defined' }[input.action];
+        done(result.files.length ? `${what} ${input.value} (${result.build}): ${result.files.join(', ')}` : `${input.value} is already in the build (${result.build}): nothing changed`);
+        for (const note of result.notes)
+            warn(note);
+        return undefined;
+    }
+}
+__decorate([
+    CLIAction('native <action> <value>', NativeDTO, { description: 'Change the build of the native addon of the current directory (binding.gyp, CMakeLists.txt, Cargo.toml): link a library, include headers, define a macro' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [NativeDTO]),
+    __metadata("design:returntype", Promise)
+], NativeController.prototype, "native", null);

package/dist/esm/controllers/PackController.js

@@ -0,0 +1,88 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import path from 'node:path';
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { BundleDTO } from '../dtos/BundleDTO.js';
+import { ExecutableDTO } from '../dtos/ExecutableDTO.js';
+import { InstallerDTO } from '../dtos/InstallerDTO.js';
+import { loadBuilder } from '../lib/Builder.js';
+import { done, step, warn } from '../lib/Output.js';
+/**
+ * A size in megabytes
+ * @param size
+ */
+function megabytes(size) {
+    return `${(size / 1024 / 1024).toFixed(1)} MB`;
+}
+/**
+ * The commands packing the application of the current directory (lakutata package): into one JavaScript file, into an
+ * executable, or into its installers
+ */
+export class PackController extends Controller {
+    async bundle(input) {
+        const { bundleProject } = await loadBuilder(process.cwd());
+        const result = await bundleProject({ project: process.cwd(), entry: input.entry, outfile: input.outfile, minify: input.minify, external: input.external });
+        done(`${path.relative(process.cwd(), result.outfile)} (${megabytes(result.size)}): node ${path.relative(process.cwd(), result.outfile)}`);
+        //The native addons are next to the bundle, which is distributed with them
+        if (result.nativeDirectory)
+            done(`${path.relative(process.cwd(), result.nativeDirectory)}: the native addons (${result.native.modules.join(', ') || 'of the application'}), distributed with the bundle`);
+        if (result.resourcesDirectory)
+            done(`${path.relative(process.cwd(), result.resourcesDirectory)}: the resources (${result.resources.join(', ')}), distributed with the bundle`);
+        return undefined;
+    }
+    async executable(input) {
+        const { buildExecutable } = await loadBuilder(process.cwd());
+        const result = await buildExecutable({ project: process.cwd(), entry: input.entry, outdir: input.outdir, minify: input.minify, external: input.external, runtime: input.runtime, layout: input.layout });
+        step(`${result.runtime} embedded`);
+        if (result.native.length)
+            step(result.directory ? `Native addons next to the executable: ${result.native.join(', ')}` : `Native addons embedded, extracted at the first run: ${result.native.join(', ')}`);
+        if (result.resources.length)
+            step(result.directory ? `Resources next to the executable: ${result.resources.join(', ')}` : `Resources embedded, extracted at the first run: ${result.resources.join(', ')}`);
+        for (const warning of result.warnings)
+            warn(warning);
+        if (result.directory)
+            done(`${path.relative(process.cwd(), result.directory)}: the executable and what it loads, distributed together`);
+        done(`${path.relative(process.cwd(), result.file)} (${result.platform}, ${megabytes(result.size)})`);
+        return undefined;
+    }
+    async installer(input) {
+        const { buildInstaller } = await loadBuilder(process.cwd());
+        const result = await buildInstaller({ project: process.cwd(), targets: input.target, outdir: input.outdir, entry: input.entry, minify: input.minify, external: input.external });
+        step(`${result.executable.runtime} embedded`);
+        if (result.executable.native.length)
+            step(`Native addons: ${result.executable.native.join(', ')}`);
+        if (result.executable.resources.length)
+            step(`Resources: ${result.executable.resources.join(', ')}`);
+        for (const warning of result.warnings)
+            warn(warning);
+        for (const file of result.files)
+            done(`${path.relative(process.cwd(), file.file)} (${file.target}, ${megabytes(file.size)})`);
+        return undefined;
+    }
+}
+__decorate([
+    CLIAction('package bundle', BundleDTO, { description: 'Bundle the compiled application and its dependencies into one file run by node' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BundleDTO]),
+    __metadata("design:returntype", Promise)
+], PackController.prototype, "bundle", null);
+__decorate([
+    CLIAction('package exe', ExecutableDTO, { description: 'Make the executable of the compiled application for this platform, which runs without Node.js installed' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ExecutableDTO]),
+    __metadata("design:returntype", Promise)
+], PackController.prototype, "executable", null);
+__decorate([
+    CLIAction('package installer', InstallerDTO, { description: 'Make the installers of the compiled application for this platform: its executable, its native addons and its resources installed, its program in the PATH, its service registered' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InstallerDTO]),
+    __metadata("design:returntype", Promise)
+], PackController.prototype, "installer", null);

package/dist/esm/controllers/WorkspaceController.js

@@ -0,0 +1,91 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import path from 'node:path';
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { RunScriptDTO } from '../dtos/RunScriptDTO.js';
+import { VersionDTO } from '../dtos/VersionDTO.js';
+import { AddPackageDTO } from '../dtos/AddPackageDTO.js';
+import { addPackage } from '../lib/AddPackage.js';
+import { done, styled, table } from '../lib/Output.js';
+import { Workspace } from '../lib/workspace/Workspace.js';
+import { runScript } from '../lib/workspace/Run.js';
+import { applyVersion, planVersion } from '../lib/workspace/Version.js';
+import { Inject } from 'lakutata/decorator/di';
+import { Translator } from 'lakutata/com/i18n';
+import { localize } from '../lib/Language.js';
+/**
+ * The commands of the workspaces: the packages of a project (app, ui, proxy…) built in the order of their dependencies, and given a same version
+ */
+export class WorkspaceController extends Controller {
+    async run(input) {
+        const workspace = await Workspace.find();
+        const result = await runScript(workspace, input.script, { concurrency: input.concurrency, bail: input.bail, parallel: input.parallel, scope: input.scope });
+        if (!result.ran.length)
+            return `No package has the script ${input.script}`;
+        done(`${input.script} ran in ${result.ran.join(', ')}`);
+        return undefined;
+    }
+    async version(input) {
+        const workspace = await Workspace.find();
+        const plan = planVersion(workspace, input.bump, input.preid);
+        process.stdout.write(table(plan.packages.map(({ name, from }) => [name, `${from ?? '-'} → ${plan.to}`]), localize(this.i18n, 'plan.version', 'Version {from} → {to}', { from: plan.from, to: styled('green', plan.to) })));
+        if (process.stdin.isTTY && process.stdout.isTTY && !input.yes) {
+            const { confirm } = await import('@inquirer/prompts');
+            if (!await confirm({ message: localize(this.i18n, 'prompts.version', 'Give this version?'), default: true }))
+                return localize(this.i18n, 'prompts.notVersioned', 'The version is not changed');
+        }
+        const files = await applyVersion(workspace, plan, { preid: input.preid, git: input.git });
+        done(`Version ${plan.to} given (${files.map((file) => path.relative(workspace.root, file)).join(', ')})${input.git ? `, committed and tagged v${plan.to}` : ''}`);
+        return undefined;
+    }
+    async add(input) {
+        const native = input.native === true ? 'gyp' : input.native || undefined;
+        const result = await addPackage({ name: input.name, native: native, to: input.to });
+        done(`${native ? `Native addon (${native})` : 'Package'} ${input.name} ${result.version} added: ${path.relative(process.cwd(), result.directory) || '.'} (${result.files.join(', ')})${result.to ? `, a dependency of ${result.to}` : ''}`);
+        process.stdout.write(`Next: npm install (links the package${native ? ', builds the addon' : ''}), then npm run rebuild -w ${input.name}\n`);
+        return undefined;
+    }
+    async list() {
+        const workspace = await Workspace.find();
+        return table(workspace.packages.map((pkg) => [
+            pkg.name,
+            `${pkg.version ?? '-'}${pkg.private ? ' (private)' : ''}  ${path.relative(workspace.root, pkg.directory)}${pkg.dependencies.length ? `  → ${pkg.dependencies.join(', ')}` : ''}`
+        ]), `${workspace.packages.length} packages, version ${workspace.version ?? '-'}`);
+    }
+}
+__decorate([
+    Inject(Translator),
+    __metadata("design:type", Translator)
+], WorkspaceController.prototype, "i18n", void 0);
+__decorate([
+    CLIAction('run <script>', RunScriptDTO, { description: 'Run a script in the packages of the workspace, in the order of their dependencies' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [RunScriptDTO]),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "run", null);
+__decorate([
+    CLIAction('version <bump>', VersionDTO, { description: 'Give the packages of the workspace their next version, and update the dependencies between them' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [VersionDTO]),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "version", null);
+__decorate([
+    CLIAction('add <name>', AddPackageDTO, { description: 'Add a package to the workspace (packages/<name>): TypeScript, or a native addon with --native [gyp|cmake|rust]' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AddPackageDTO]),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "add", null);
+__decorate([
+    CLIAction('list', { description: 'List the packages of the workspace' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "list", null);

package/dist/esm/dtos/AddPackageDTO.js

@@ -0,0 +1,25 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class AddPackageDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.String().required().description('The name of the package (packages/<name> of the workspace)')),
+    __metadata("design:type", String)
+], AddPackageDTO.prototype, "name", void 0);
+__decorate([
+    Expect(DTO.Alternatives(DTO.Boolean(), DTO.String().valid('gyp', 'cmake', 'rust')).optional().default(false).description('A native addon, by its build system: gyp (C++, node-gyp, by default), cmake (C++, cmake-js) or rust (napi-rs)')),
+    __metadata("design:type", Object)
+], AddPackageDTO.prototype, "native", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The package of the workspace depending on it')),
+    __metadata("design:type", String)
+], AddPackageDTO.prototype, "to", void 0);

package/dist/esm/dtos/BundleDTO.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class BundleDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.String().optional().description('The compiled entry of the application (the "main" of the package.json by default)')),
+    __metadata("design:type", String)
+], BundleDTO.prototype, "entry", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The bundle (dist/<name>.cjs by default)')),
+    __metadata("design:type", String)
+], BundleDTO.prototype, "outfile", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(true).description('Minify the bundle')),
+    __metadata("design:type", Boolean)
+], BundleDTO.prototype, "minify", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional().description('The modules left out of the bundle, loaded at run time from a node_modules next to it (the native addons are handled)')),
+    __metadata("design:type", Array)
+], BundleDTO.prototype, "external", void 0);

package/dist/esm/dtos/CleanDTO.js

@@ -0,0 +1,17 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class CleanDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional().description('The paths removed, relative to the package (the outDir and the declarationDir of its tsconfig.json by default)')),
+    __metadata("design:type", Array)
+], CleanDTO.prototype, "paths", void 0);