@hexabot-ai/cli 3.0.0-alpha.3

package/dist/commands/__tests__/docker.test.js

@@ -0,0 +1,132 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const loadProjectConfig = jest.fn();
+const dockerCompose = jest.fn();
+const generateComposeFiles = jest.fn();
+const resolveComposeFile = jest.fn();
+const bootstrapEnvFile = jest.fn();
+const checkDocker = jest.fn();
+const assertHexabotProject = jest.fn();
+const ensureDockerFolder = jest.fn();
+const parseServices = jest.fn();
+const runStart = jest.fn();
+jest.unstable_mockModule('../../core/config.js', () => ({
+    loadProjectConfig,
+}));
+jest.unstable_mockModule('../../core/docker.js', () => ({
+    dockerCompose,
+    generateComposeFiles,
+    resolveComposeFile,
+}));
+jest.unstable_mockModule('../../core/env.js', () => ({
+    bootstrapEnvFile,
+}));
+jest.unstable_mockModule('../../core/prerequisites.js', () => ({
+    checkDocker,
+}));
+jest.unstable_mockModule('../../core/project.js', () => ({
+    assertHexabotProject,
+    ensureDockerFolder,
+}));
+jest.unstable_mockModule('../../utils/services.js', () => ({
+    parseServices,
+}));
+jest.unstable_mockModule('../start.js', () => ({
+    runStart,
+}));
+let registerDockerCommand;
+beforeAll(async () => {
+    ({ registerDockerCommand } = await import('../docker.js'));
+});
+beforeEach(() => {
+    jest.resetAllMocks();
+    parseServices.mockImplementation((value) => (typeof value === 'string' ? value : '')
+        .split(',')
+        .filter((entry) => entry));
+    resolveComposeFile.mockReturnValue('/project/docker/docker-compose.yml');
+    generateComposeFiles.mockReturnValue('-f docker-compose.yml');
+    loadProjectConfig.mockReturnValue({
+        docker: {
+            composeFile: 'docker/docker-compose.yml',
+            defaultServices: ['api'],
+        },
+        env: {
+            docker: '.env.docker',
+            dockerExample: '.env.docker.example',
+        },
+    });
+});
+const createProgram = () => {
+    const program = new Command();
+    registerDockerCommand(program);
+    return program;
+};
+describe('registerDockerCommand', () => {
+    it('runs docker compose up with extra flags and services', async () => {
+        const program = createProgram();
+        await program.parseAsync([
+            'node',
+            'test',
+            'docker',
+            'up',
+            '--services',
+            'api,postgres',
+            '--build',
+            '--detach',
+        ]);
+        expect(bootstrapEnvFile).toHaveBeenCalled();
+        expect(generateComposeFiles).toHaveBeenCalledWith('/project/docker/docker-compose.yml', ['api', 'postgres'], 'dev');
+        expect(dockerCompose).toHaveBeenCalledWith(expect.stringContaining('up --build -d'));
+    });
+    it('runs docker compose down with optional volume removal', async () => {
+        const program = createProgram();
+        await program.parseAsync(['node', 'test', 'docker', 'down', '--volumes']);
+        expect(dockerCompose).toHaveBeenCalledWith(expect.stringContaining('down -v'));
+        expect(bootstrapEnvFile).not.toHaveBeenCalled();
+    });
+    it('tails docker logs with filters', async () => {
+        const program = createProgram();
+        await program.parseAsync([
+            'node',
+            'test',
+            'docker',
+            'logs',
+            'api',
+            '--follow',
+            '--since',
+            '1h',
+        ]);
+        expect(dockerCompose).toHaveBeenCalledWith(expect.stringContaining('logs -f --since 1h api'));
+    });
+    it('lists running services with docker ps', async () => {
+        const program = createProgram();
+        await program.parseAsync(['node', 'test', 'docker', 'ps']);
+        expect(dockerCompose).toHaveBeenCalledWith(expect.stringContaining('ps'));
+    });
+    it('delegates to start command for docker start', async () => {
+        const program = createProgram();
+        await program.parseAsync([
+            'node',
+            'test',
+            'docker',
+            'start',
+            '--services',
+            'api',
+            '--build',
+            '--detach',
+            '--env-bootstrap',
+        ]);
+        expect(runStart).toHaveBeenCalledWith({
+            docker: true,
+            services: 'api',
+            build: true,
+            detach: true,
+            envBootstrap: true,
+        });
+    });
+});

package/dist/commands/__tests__/env.test.js

@@ -0,0 +1,72 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const loadProjectConfig = jest.fn();
+const bootstrapEnvFile = jest.fn();
+const listEnvStatus = jest.fn();
+const assertHexabotProject = jest.fn();
+jest.unstable_mockModule('../../core/config.js', () => ({
+    loadProjectConfig,
+}));
+jest.unstable_mockModule('../../core/env.js', () => ({
+    bootstrapEnvFile,
+    listEnvStatus,
+}));
+jest.unstable_mockModule('../../core/project.js', () => ({
+    assertHexabotProject,
+}));
+let registerEnvCommand;
+beforeAll(async () => {
+    ({ registerEnvCommand } = await import('../env.js'));
+});
+beforeEach(() => {
+    jest.resetAllMocks();
+    loadProjectConfig.mockReturnValue({
+        env: {
+            local: '.env',
+            localExample: '.env.example',
+            docker: '.env.docker',
+            dockerExample: '.env.docker.example',
+        },
+    });
+});
+describe('registerEnvCommand', () => {
+    it('bootstraps env files for docker or local targets', async () => {
+        const dockerProgram = new Command();
+        registerEnvCommand(dockerProgram);
+        await dockerProgram.parseAsync([
+            'node',
+            'test',
+            'env',
+            'init',
+            '--docker',
+            '--force',
+        ]);
+        expect(bootstrapEnvFile).toHaveBeenCalledWith(expect.any(String), '.env.docker.example', '.env.docker', { force: true });
+        jest.clearAllMocks();
+        const localProgram = new Command();
+        registerEnvCommand(localProgram);
+        await localProgram.parseAsync(['node', 'test', 'env', 'init']);
+        expect(bootstrapEnvFile).toHaveBeenCalledWith(expect.any(String), '.env.example', '.env', { force: undefined });
+    });
+    it('lists env statuses with formatted output', async () => {
+        const statuses = [
+            { file: '.env', exists: true },
+            { file: '.env.docker', exists: false },
+        ];
+        listEnvStatus.mockReturnValue(statuses);
+        const logs = [];
+        jest.spyOn(console, 'log').mockImplementation((message) => {
+            logs.push(String(message));
+        });
+        const program = new Command();
+        registerEnvCommand(program);
+        await program.parseAsync(['node', 'test', 'env', 'list']);
+        expect(logs.join('\n')).toContain('.env');
+        expect(logs.join('\n')).toContain('.env.docker');
+    });
+});

package/dist/commands/__tests__/migrate.test.js

@@ -0,0 +1,42 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const dockerExec = jest.fn();
+const ensureDockerFolder = jest.fn();
+const checkDocker = jest.fn();
+jest.unstable_mockModule('../../core/docker.js', () => ({
+    dockerExec,
+}));
+jest.unstable_mockModule('../../core/project.js', () => ({
+    ensureDockerFolder,
+}));
+jest.unstable_mockModule('../../core/prerequisites.js', () => ({
+    checkDocker,
+}));
+let registerMigrateCommand;
+beforeAll(async () => {
+    ({ registerMigrateCommand } = await import('../migrate.js'));
+});
+describe('registerMigrateCommand', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        ensureDockerFolder.mockReturnValue('/workspace/docker');
+    });
+    it('runs migrations with additional arguments', async () => {
+        const program = new Command();
+        registerMigrateCommand(program);
+        await program.parseAsync(['node', 'test', 'migrate', 'seed', '20241128']);
+        expect(ensureDockerFolder).toHaveBeenCalled();
+        expect(dockerExec).toHaveBeenCalledWith('api', 'npm run migrate seed 20241128', '--user $(id -u):$(id -g)');
+    });
+    it('runs migrations without extra arguments', async () => {
+        const program = new Command();
+        registerMigrateCommand(program);
+        await program.parseAsync(['node', 'test', 'migrate']);
+        expect(dockerExec).toHaveBeenCalledWith('api', 'npm run migrate', '--user $(id -u):$(id -g)');
+    });
+});

package/dist/commands/__tests__/start.test.js

@@ -0,0 +1,120 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { jest } from '@jest/globals';
+const loadProjectConfig = jest.fn();
+const updateProjectConfig = jest.fn();
+const dockerCompose = jest.fn();
+const generateComposeFiles = jest.fn();
+const resolveComposeFile = jest.fn();
+const bootstrapEnvFile = jest.fn();
+const resolveEnvExample = jest.fn();
+const detectPackageManager = jest.fn();
+const normalizePackageManager = jest.fn();
+const runPackageScript = jest.fn();
+const checkDocker = jest.fn();
+const assertHexabotProject = jest.fn();
+const ensureDockerFolder = jest.fn();
+jest.unstable_mockModule('../../core/config.js', () => ({
+    loadProjectConfig,
+    updateProjectConfig,
+}));
+jest.unstable_mockModule('../../core/docker.js', () => ({
+    dockerCompose,
+    generateComposeFiles,
+    resolveComposeFile,
+}));
+jest.unstable_mockModule('../../core/env.js', () => ({
+    bootstrapEnvFile,
+    resolveEnvExample,
+}));
+jest.unstable_mockModule('../../core/package-manager.js', () => ({
+    detectPackageManager,
+    normalizePackageManager,
+    runPackageScript,
+}));
+jest.unstable_mockModule('../../core/prerequisites.js', () => ({
+    checkDocker,
+}));
+jest.unstable_mockModule('../../core/project.js', () => ({
+    assertHexabotProject,
+    ensureDockerFolder,
+}));
+jest.unstable_mockModule('../../utils/services.js', () => ({
+    parseServices: (value) => value.split(',').filter(Boolean),
+}));
+let runStart;
+beforeAll(async () => {
+    ({ runStart } = await import('../start.js'));
+});
+beforeEach(() => {
+    jest.resetAllMocks();
+    normalizePackageManager.mockImplementation((value) => value);
+});
+describe('runStart', () => {
+    const baseConfig = {
+        startScript: 'start',
+        packageManager: 'npm',
+        docker: {
+            composeFile: 'docker/docker-compose.yml',
+            defaultServices: [],
+        },
+        env: {
+            local: '.env',
+            localExample: '.env.example',
+            docker: '.env.docker',
+            dockerExample: '.env.docker.example',
+        },
+    };
+    it('runs the npm start script when not using Docker', async () => {
+        loadProjectConfig.mockReturnValue(baseConfig);
+        await runStart();
+        expect(assertHexabotProject).toHaveBeenCalled();
+        expect(runPackageScript).toHaveBeenCalledWith('npm', 'start', expect.any(String));
+        expect(detectPackageManager).not.toHaveBeenCalled();
+        expect(updateProjectConfig).not.toHaveBeenCalled();
+        expect(dockerCompose).not.toHaveBeenCalled();
+    });
+    it('runs docker compose in prod mode with env bootstrap', async () => {
+        const config = {
+            ...baseConfig,
+            packageManager: undefined,
+            docker: {
+                composeFile: 'docker/docker-compose.yml',
+                defaultServices: ['api'],
+            },
+        };
+        loadProjectConfig.mockReturnValue(config);
+        detectPackageManager.mockReturnValue('pnpm');
+        resolveComposeFile.mockReturnValue('/tmp/docker/docker-compose.yml');
+        generateComposeFiles.mockReturnValue('-f docker-compose.yml');
+        await runStart({
+            docker: true,
+            services: 'api,postgres',
+            envBootstrap: true,
+            build: true,
+            detach: true,
+        });
+        expect(detectPackageManager).toHaveBeenCalled();
+        expect(updateProjectConfig).toHaveBeenCalledWith(expect.any(String), {
+            packageManager: 'pnpm',
+        });
+        expect(bootstrapEnvFile).toHaveBeenCalledWith(expect.any(String), config.env.dockerExample, config.env.docker);
+        expect(resolveEnvExample).not.toHaveBeenCalled();
+        expect(checkDocker).toHaveBeenCalled();
+        expect(ensureDockerFolder).toHaveBeenCalled();
+        expect(generateComposeFiles).toHaveBeenCalledWith('/tmp/docker/docker-compose.yml', ['api', 'postgres'], 'prod');
+        expect(dockerCompose).toHaveBeenCalledWith(expect.stringContaining('up --build -d'));
+        expect(runPackageScript).not.toHaveBeenCalled();
+    });
+    it('bootstraps envs for local start when requested', async () => {
+        loadProjectConfig.mockReturnValue(baseConfig);
+        resolveEnvExample.mockReturnValue('.env.local.example');
+        await runStart({ envBootstrap: true, env: '.env.local' });
+        expect(resolveEnvExample).toHaveBeenCalledWith(expect.any(String), '.env.local', baseConfig.env.localExample);
+        expect(bootstrapEnvFile).toHaveBeenCalledWith(expect.any(String), '.env.local.example', '.env.local');
+        expect(runPackageScript).toHaveBeenCalled();
+    });
+});

package/dist/commands/check.js

@@ -0,0 +1,73 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import chalk from 'chalk';
+import { loadProjectConfig } from '../core/config.js';
+import { listEnvStatus } from '../core/env.js';
+import { checkDocker, checkNodeVersion } from '../core/prerequisites.js';
+import { isHexabotProject } from '../core/project.js';
+export const registerCheckCommand = (program) => {
+    program
+        .command('check')
+        .description('Run diagnostic checks')
+        .option('--docker-only', 'Only run Docker checks')
+        .option('--no-docker', 'Skip Docker checks')
+        .action((options) => {
+        runDiagnostics({
+            dockerOnly: options.dockerOnly,
+            noDocker: options.noDocker ?? options.docker === false,
+        });
+    });
+};
+const runDiagnostics = (options) => {
+    const projectRoot = process.cwd();
+    const onlyDocker = options.dockerOnly;
+    const skipDocker = options.noDocker;
+    const results = [];
+    if (!onlyDocker) {
+        const nodeResult = checkNodeVersion({ fatal: false, silent: true });
+        results.push({
+            label: 'Node.js version',
+            ok: nodeResult.ok,
+            message: nodeResult.message,
+        });
+        const projectResult = isHexabotProject(projectRoot);
+        results.push({
+            label: 'Hexabot project',
+            ok: projectResult,
+            message: projectResult
+                ? 'Found @hexabot-ai/api in package.json'
+                : 'Run inside a Hexabot project directory',
+        });
+        if (projectResult) {
+            const config = loadProjectConfig(projectRoot);
+            const envStatuses = listEnvStatus(projectRoot, config);
+            envStatuses.forEach((status) => {
+                results.push({
+                    label: `Env file ${status.file}`,
+                    ok: status.exists,
+                    message: status.exists ? 'Found' : 'Missing',
+                });
+            });
+        }
+    }
+    if (!skipDocker) {
+        const dockerResult = checkDocker({ fatal: false, silent: true });
+        results.push({
+            label: 'Docker',
+            ok: dockerResult.ok,
+            message: dockerResult.message,
+        });
+    }
+    const hasErrors = results.some((result) => !result.ok);
+    results.forEach((result) => printResult(result));
+    if (hasErrors) {
+        process.exitCode = 1;
+    }
+};
+const printResult = (result) => {
+    const status = result.ok ? chalk.green('PASS') : chalk.red('FAIL');
+    console.log(`${status} ${result.label}${result.message ? ` — ${result.message}` : ''}`);
+};

package/dist/commands/config.js

@@ -0,0 +1,76 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import * as path from 'path';
+import chalk from 'chalk';
+import { loadProjectConfig, updateProjectConfig } from '../core/config.js';
+import { normalizePackageManager } from '../core/package-manager.js';
+import { assertHexabotProject } from '../core/project.js';
+export const registerConfigCommand = (program) => {
+    const configCommand = program.command('config').description('Project config');
+    configCommand
+        .command('show')
+        .description('Print effective Hexabot configuration')
+        .action(() => {
+        const projectRoot = path.resolve(process.cwd());
+        assertHexabotProject(projectRoot);
+        const config = loadProjectConfig(projectRoot);
+        console.log(JSON.stringify(config, null, 2));
+    });
+    configCommand
+        .command('set <key> <value>')
+        .description('Update a configuration value (dot notation)')
+        .action((key, value) => {
+        const projectRoot = path.resolve(process.cwd());
+        assertHexabotProject(projectRoot);
+        const normalizedValue = parseValue(key, value);
+        const override = buildOverride(key.split('.'), normalizedValue);
+        const updated = updateProjectConfig(projectRoot, override);
+        console.log(chalk.green('Updated hexabot.config.json'));
+        console.log(JSON.stringify(updated, null, 2));
+    });
+};
+const parseValue = (key, value) => {
+    if (key === 'packageManager') {
+        return normalizePackageManager(value);
+    }
+    const trimmed = value.trim();
+    if (trimmed === 'true') {
+        return true;
+    }
+    if (trimmed === 'false') {
+        return false;
+    }
+    if (!Number.isNaN(Number(trimmed)) && trimmed !== '') {
+        return Number(trimmed);
+    }
+    if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch (_error) {
+            // fallback to string
+        }
+    }
+    if (trimmed.includes(',') && key.endsWith('Services')) {
+        return trimmed
+            .split(',')
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    return trimmed;
+};
+const buildOverride = (parts, value) => {
+    if (!parts.length) {
+        return {};
+    }
+    const [head, ...rest] = parts;
+    if (!head) {
+        return buildOverride(rest, value);
+    }
+    return {
+        [head]: rest.length ? buildOverride(rest, value) : value,
+    };
+};

package/dist/commands/create.js

@@ -0,0 +1,131 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { ensureProjectConfig, loadProjectConfig } from '../core/config.js';
+import { bootstrapEnvFile } from '../core/env.js';
+import { detectPackageManager, installDependencies, normalizePackageManager, } from '../core/package-manager.js';
+import { downloadAndExtractTemplate } from '../services/templates.js';
+import { validateProjectName } from '../utils/validation.js';
+import { runDev } from './dev.js';
+const DEFAULT_TEMPLATE_REPO = 'hexastack/hexabot-template-starter';
+export const registerCreateCommand = (program) => {
+    program
+        .command('create <projectName>')
+        .description('Create a new Hexabot project from the starter')
+        .option('-t, --template <name>', 'Project template to use (default: starter)')
+        .option('--pm <npm|pnpm|yarn|bun>', 'Preferred package manager')
+        .option('--no-install', 'Skip installing dependencies')
+        .option('--dev', 'Run hexabot dev after creation')
+        .option('--docker', 'Bootstrap Docker env files during creation')
+        .option('--force', 'Allow scaffolding into a non-empty directory')
+        .action(async (projectName, options) => {
+        await createProject(projectName, options);
+    });
+};
+const createProject = async (projectName, options) => {
+    if (!validateProjectName(projectName)) {
+        console.error(chalk.red('Invalid project name. Use lowercase letters, numbers, and dashes.'));
+        process.exit(1);
+    }
+    const projectPath = path.join(process.cwd(), projectName);
+    ensureTargetDirectory(projectPath, options.force);
+    const templateRepo = resolveTemplateRepo(options.template);
+    console.log(chalk.blue(`Using template ${templateRepo}`));
+    try {
+        const latestTag = await fetchLatestReleaseTag(templateRepo);
+        const templateUrl = `https://github.com/${templateRepo}/archive/refs/tags/${latestTag}.zip`;
+        await downloadAndExtractTemplate(templateUrl, projectPath);
+        const pmPreference = normalizePackageManager(options.pm);
+        const detectedPm = detectPackageManager(projectPath);
+        const packageManager = pmPreference || detectedPm;
+        const configOverrides = {
+            packageManager,
+        };
+        ensureProjectConfig(projectPath, configOverrides);
+        const config = loadProjectConfig(projectPath);
+        bootstrapEnvFile(projectPath, config.env.localExample, config.env.local, {
+            quiet: true,
+        });
+        if (options.docker) {
+            bootstrapEnvFile(projectPath, config.env.dockerExample, config.env.docker, { quiet: true });
+        }
+        if (options.noInstall) {
+            console.log(chalk.yellow('Skipping dependency installation (--no-install).'));
+        }
+        else {
+            console.log(chalk.blue(`Installing dependencies with ${packageManager}...`));
+            installDependencies(packageManager, projectPath);
+        }
+        logSuccessMessage(projectName, { docker: options.docker });
+        if (options.dev) {
+            if (options.noInstall) {
+                console.log(chalk.yellow('Dependencies were not installed. Run `npm install` before `--dev`.'));
+            }
+            else {
+                console.log(chalk.blue('Starting dev server...'));
+                await runDev({
+                    cwd: projectPath,
+                    docker: options.docker,
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error creating project.'), error);
+        process.exit(1);
+    }
+};
+const resolveTemplateRepo = (template) => {
+    if (!template) {
+        return DEFAULT_TEMPLATE_REPO;
+    }
+    if (template.includes('/')) {
+        return template;
+    }
+    return `hexastack/hexabot-template-${template}`;
+};
+const ensureTargetDirectory = (projectPath, force) => {
+    if (fs.existsSync(projectPath)) {
+        const isEmpty = fs.readdirSync(projectPath).length === 0;
+        if (!isEmpty && !force) {
+            console.error(chalk.red(`Directory ${projectPath} is not empty. Use --force to scaffold anyway.`));
+            process.exit(1);
+        }
+    }
+    else {
+        fs.mkdirSync(projectPath, { recursive: true });
+    }
+};
+const fetchLatestReleaseTag = async (templateRepo) => {
+    const response = await fetch(`https://api.github.com/repos/${templateRepo}/releases/latest`);
+    const data = await response.json();
+    if (!response.ok) {
+        throw new Error(`Failed to fetch the latest release information: ${data.message}`);
+    }
+    return data.tag_name;
+};
+const logSuccessMessage = (projectName, options) => {
+    console.log('\n');
+    console.log(chalk.green(`🎉 Project ${projectName} created successfully.`));
+    console.log('\n');
+    console.log(chalk.bgYellow.black(`Next steps:`));
+    console.log(chalk.gray(`1. Navigate to the project folder:`));
+    console.log(chalk.yellow(`   cd ${projectName}`));
+    if (options.docker) {
+        console.log(chalk.gray(`2. Run dev mode with Docker (or omit --docker for local sqlite):`));
+        console.log(chalk.yellow(`   hexabot dev --docker`));
+    }
+    else {
+        console.log(chalk.gray(`2. Start local dev server (SQLite by default):`));
+        console.log(chalk.yellow(`   hexabot dev`));
+    }
+    console.log(chalk.gray(`3. Explore docker helpers if needed:`));
+    console.log(chalk.yellow(`   hexabot docker up --services postgres`));
+    console.log(chalk.gray(`Need env files? Run ${chalk.white('hexabot env init --docker')}`));
+    console.log('\n');
+};