@hexabot-ai/cli 3.0.0-alpha.3

package/dist/core/__tests__/project.test.js

@@ -0,0 +1,49 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { jest } from '@jest/globals';
+import { ensureDockerFolder, resolveDockerFolder } from '../project.js';
+describe('project helpers', () => {
+    let tempDirs = [];
+    afterEach(() => {
+        jest.restoreAllMocks();
+        tempDirs.forEach((dir) => fs.rmSync(dir, {
+            recursive: true,
+            force: true,
+        }));
+        tempDirs = [];
+    });
+    const createTempDir = (withDockerFolder) => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'hexabot-project-'));
+        tempDirs.push(dir);
+        if (withDockerFolder) {
+            fs.mkdirSync(path.join(dir, 'docker'));
+        }
+        return dir;
+    };
+    it('resolves the docker folder relative to the working directory', () => {
+        jest.spyOn(process, 'cwd').mockReturnValue('/workspace/hexabot');
+        expect(resolveDockerFolder()).toBe(path.resolve('/workspace/hexabot', './docker'));
+    });
+    it('returns the folder path when it exists', () => {
+        const cwd = createTempDir(true);
+        jest.spyOn(process, 'cwd').mockReturnValue(cwd);
+        expect(ensureDockerFolder()).toBe(path.resolve(cwd, './docker'));
+    });
+    it('exits the process when the docker folder is missing', () => {
+        const cwd = createTempDir(false);
+        jest.spyOn(process, 'cwd').mockReturnValue(cwd);
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation(() => { });
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`exit:${code}`);
+        }));
+        expect(() => ensureDockerFolder()).toThrow('exit:1');
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+});

package/dist/core/config.js

@@ -0,0 +1,78 @@
+/*
+ * 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';
+const CONFIG_FILE_NAME = 'hexabot.config.json';
+const DEFAULT_CONFIG = {
+    devScript: 'dev',
+    startScript: 'start',
+    docker: {
+        composeFile: 'docker/docker-compose.yml',
+        defaultServices: [],
+    },
+    env: {
+        local: '.env',
+        localExample: '.env.example',
+        docker: '.env.docker',
+        dockerExample: '.env.docker.example',
+    },
+};
+export const resolveConfigPath = (projectRoot = process.cwd()) => {
+    return path.join(projectRoot, CONFIG_FILE_NAME);
+};
+export const loadProjectConfig = (projectRoot = process.cwd()) => {
+    const configPath = resolveConfigPath(projectRoot);
+    if (!fs.existsSync(configPath)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return mergeConfig(DEFAULT_CONFIG, parsed);
+    }
+    catch (error) {
+        console.warn(chalk.yellow('Invalid hexabot.config.json. Using defaults.'));
+        console.warn(chalk.yellow(error.message));
+        return { ...DEFAULT_CONFIG };
+    }
+};
+export const ensureProjectConfig = (projectRoot = process.cwd(), overrides = {}) => {
+    const configPath = resolveConfigPath(projectRoot);
+    if (!fs.existsSync(configPath)) {
+        const config = mergeConfig(DEFAULT_CONFIG, overrides);
+        writeProjectConfig(config, projectRoot);
+        return config;
+    }
+    if (Object.keys(overrides).length > 0) {
+        return updateProjectConfig(projectRoot, overrides);
+    }
+    return loadProjectConfig(projectRoot);
+};
+export const writeProjectConfig = (config, projectRoot = process.cwd()) => {
+    const configPath = resolveConfigPath(projectRoot);
+    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+};
+export const updateProjectConfig = (projectRoot, overrides) => {
+    const existing = loadProjectConfig(projectRoot);
+    const next = mergeConfig(existing, overrides);
+    writeProjectConfig(next, projectRoot);
+    return next;
+};
+const mergeConfig = (base, overrides) => {
+    return {
+        ...base,
+        ...overrides,
+        docker: {
+            ...base.docker,
+            ...(overrides.docker || {}),
+        },
+        env: {
+            ...base.env,
+            ...(overrides.env || {}),
+        },
+    };
+};

package/dist/core/docker.js

@@ -0,0 +1,66 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+export const resolveComposeFile = (projectRoot, filePath) => {
+    return path.isAbsolute(filePath)
+        ? filePath
+        : path.join(projectRoot, filePath);
+};
+export const generateComposeFiles = (baseComposeFile, services, mode) => {
+    if (!fs.existsSync(baseComposeFile)) {
+        console.error(chalk.red(`Docker compose file not found at ${baseComposeFile}. Update hexabot.config.json.`));
+        process.exit(1);
+    }
+    const composeDir = path.dirname(baseComposeFile);
+    const files = [`-f ${baseComposeFile}`];
+    services.forEach((service) => {
+        const serviceFile = path.join(composeDir, `docker-compose.${service}.yml`);
+        if (fs.existsSync(serviceFile)) {
+            files.push(`-f ${serviceFile}`);
+        }
+        if (mode) {
+            const serviceModeFile = path.join(composeDir, `docker-compose.${service}.${mode}.yml`);
+            if (fs.existsSync(serviceModeFile)) {
+                files.push(`-f ${serviceModeFile}`);
+            }
+        }
+    });
+    if (mode) {
+        const modeFile = path.join(composeDir, `docker-compose.${mode}.yml`);
+        if (fs.existsSync(modeFile)) {
+            files.push(`-f ${modeFile}`);
+        }
+    }
+    return files.join(' ');
+};
+export const dockerCompose = (args) => {
+    try {
+        const cmd = `docker compose ${args}`;
+        console.log(chalk.yellow(cmd));
+        execSync(cmd, { stdio: 'inherit' });
+    }
+    catch (_error) {
+        console.error(chalk.red('Error executing Docker Compose command.'));
+        process.exit(1);
+    }
+};
+export const dockerExec = (container, command, options) => {
+    try {
+        const optionalArgs = options ? `${options} ` : '';
+        const cmd = `docker exec -it ${optionalArgs}${container} ${command}`;
+        console.log(chalk.bgYellow(cmd));
+        execSync(cmd, {
+            stdio: 'inherit',
+        });
+    }
+    catch (_error) {
+        console.error(chalk.red('Error executing Docker Exec command.'));
+        process.exit(1);
+    }
+};

package/dist/core/env.js

@@ -0,0 +1,50 @@
+/*
+ * 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';
+export const bootstrapEnvFile = (projectRoot, exampleFile, targetFile, options = {}) => {
+    const examplePath = path.join(projectRoot, exampleFile);
+    const targetPath = path.join(projectRoot, targetFile);
+    if (!fs.existsSync(examplePath)) {
+        console.log(chalk.yellow(`Example env file "${exampleFile}" is missing. Skipping bootstrap.`));
+        return false;
+    }
+    if (!options.force && fs.existsSync(targetPath)) {
+        if (!options.quiet) {
+            console.log(chalk.gray(`Env file "${targetFile}" already exists. Use --force to overwrite.`));
+        }
+        return false;
+    }
+    fs.copyFileSync(examplePath, targetPath);
+    if (!options.quiet) {
+        console.log(chalk.green(`Generated ${targetFile} from ${exampleFile}. Customize it!`));
+    }
+    return true;
+};
+export const listEnvStatus = (projectRoot, config) => {
+    const entries = [
+        config.env.localExample,
+        config.env.local,
+        config.env.dockerExample,
+        config.env.docker,
+    ];
+    return entries.map((file) => ({
+        file,
+        path: path.join(projectRoot, file),
+        exists: fs.existsSync(path.join(projectRoot, file)),
+    }));
+};
+export const resolveEnvExample = (projectRoot, envFile, defaultExample) => {
+    if (!envFile) {
+        return defaultExample;
+    }
+    const candidate = `${envFile}.example`;
+    if (fs.existsSync(path.join(projectRoot, candidate))) {
+        return candidate;
+    }
+    return defaultExample;
+};

package/dist/core/package-manager.js

@@ -0,0 +1,87 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { readPackageJson } from './project.js';
+const PACKAGE_MANAGER_LOCKFILES = {
+    npm: 'package-lock.json',
+    pnpm: 'pnpm-lock.yaml',
+    yarn: 'yarn.lock',
+    bun: 'bun.lockb',
+};
+export const normalizePackageManager = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (!Object.keys(PACKAGE_MANAGER_LOCKFILES).includes(normalized)) {
+        console.error(chalk.red(`Unsupported package manager "${value}". Use npm, pnpm, yarn, or bun.`));
+        process.exit(1);
+    }
+    return normalized;
+};
+export const detectPackageManager = (projectRoot = process.cwd()) => {
+    const entries = Object.entries(PACKAGE_MANAGER_LOCKFILES);
+    for (const [pm, lockfile] of entries) {
+        if (fs.existsSync(path.join(projectRoot, lockfile))) {
+            return pm;
+        }
+    }
+    return 'npm';
+};
+export const installDependencies = (pm, projectRoot = process.cwd()) => {
+    const command = getInstallCommand(pm);
+    runCommand(command, projectRoot);
+};
+export const runPackageScript = (pm, script, projectRoot = process.cwd(), scriptArgs = []) => {
+    ensureScriptExists(script, projectRoot);
+    const command = getRunScriptCommand(pm, script, scriptArgs);
+    runCommand(command, projectRoot);
+};
+const ensureScriptExists = (script, projectRoot) => {
+    const packageJson = readPackageJson(projectRoot);
+    if (!packageJson?.scripts?.[script]) {
+        console.error(chalk.red(`Cannot find script "${script}" in package.json. Update hexabot.config.json or package.json scripts.`));
+        process.exit(1);
+    }
+};
+const getInstallCommand = (pm) => {
+    switch (pm) {
+        case 'pnpm':
+            return 'pnpm install';
+        case 'yarn':
+            return 'yarn install';
+        case 'bun':
+            return 'bun install';
+        default:
+            return 'npm install';
+    }
+};
+const getRunScriptCommand = (pm, script, args) => {
+    const joinedArgs = args.join(' ');
+    switch (pm) {
+        case 'pnpm':
+            return joinedArgs
+                ? `pnpm run ${script} -- ${joinedArgs}`
+                : `pnpm run ${script}`;
+        case 'yarn':
+            return joinedArgs ? `yarn ${script} ${joinedArgs}` : `yarn ${script}`;
+        case 'bun':
+            return joinedArgs
+                ? `bun run ${script} ${joinedArgs}`
+                : `bun run ${script}`;
+        default:
+            return joinedArgs
+                ? `npm run ${script} -- ${joinedArgs}`
+                : `npm run ${script}`;
+    }
+};
+const runCommand = (command, projectRoot) => {
+    console.log(chalk.cyan(command));
+    execSync(command, { cwd: projectRoot, stdio: 'inherit' });
+};

package/dist/core/prerequisites.js

@@ -0,0 +1,80 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+const REQUIRED_NODE_VERSION = '20.18.1';
+export const checkPrerequisites = (options = {}) => {
+    checkNodeVersion(options);
+    if (options.docker) {
+        checkDocker(options);
+    }
+};
+export const checkNodeVersion = (options = {}) => {
+    try {
+        const nodeVersion = execSync('node --version', {
+            encoding: 'utf-8',
+        }).trim();
+        const currentNodeVersion = normalizeVersion(nodeVersion);
+        if (compareVersions(currentNodeVersion, REQUIRED_NODE_VERSION) >= 0) {
+            const message = `Node.js ${nodeVersion} ✓`;
+            logSuccess(message, options);
+            return { ok: true, message };
+        }
+        const message = `Node.js version must be at least ${REQUIRED_NODE_VERSION}. Current version: ${nodeVersion}.`;
+        handleFailure(message, options);
+        return { ok: false, message };
+    }
+    catch (error) {
+        const message = "Node.js is not accessible or installed correctly. Install Node.js v20.18.1+ and ensure it's in your PATH.";
+        handleFailure(message, options, error);
+        return { ok: false, message, details: error.message };
+    }
+};
+export const checkDocker = (options = {}) => {
+    try {
+        const dockerVersion = execSync('docker --version', {
+            encoding: 'utf-8',
+        }).trim();
+        const message = `Docker is installed: ${dockerVersion}`;
+        logSuccess(message, options);
+        return { ok: true, message };
+    }
+    catch (error) {
+        const message = 'Docker is required for this command. Please install Docker.';
+        handleFailure(message, options, error);
+        return { ok: false, message, details: error.message };
+    }
+};
+const normalizeVersion = (version) => {
+    return version.startsWith('v') ? version.slice(1) : version;
+};
+const compareVersions = (current, required) => {
+    const currentParts = current.split('.').map(Number);
+    const requiredParts = required.split('.').map(Number);
+    for (let i = 0; i < requiredParts.length; i++) {
+        if ((currentParts[i] || 0) > (requiredParts[i] || 0)) {
+            return 1;
+        }
+        else if ((currentParts[i] || 0) < (requiredParts[i] || 0)) {
+            return -1;
+        }
+    }
+    return 0;
+};
+const logSuccess = (message, options) => {
+    if (!options.silent) {
+        console.log(chalk.green(message));
+    }
+};
+const handleFailure = (message, options, error) => {
+    console.error(chalk.red(message));
+    if (options.fatal !== false) {
+        if (error && options.silent) {
+            console.error(chalk.red(error.message));
+        }
+        process.exit(1);
+    }
+};

package/dist/core/project.js

@@ -0,0 +1,58 @@
+/*
+ * 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';
+const DOCKER_FOLDER_NAME = 'docker';
+const HEXABOT_PACKAGE = '@hexabot-ai/api';
+export const resolveProjectRoot = (cwd = process.cwd()) => {
+    return path.resolve(cwd);
+};
+export const readPackageJson = (projectRoot = process.cwd()) => {
+    try {
+        const packageJsonPath = path.join(projectRoot, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            return null;
+        }
+        return JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    }
+    catch (_error) {
+        return null;
+    }
+};
+export const isHexabotProject = (projectRoot = process.cwd()) => {
+    const packageJson = readPackageJson(projectRoot);
+    if (!packageJson) {
+        return false;
+    }
+    return hasHexabotDependency(packageJson);
+};
+export const assertHexabotProject = (projectRoot = process.cwd()) => {
+    if (!isHexabotProject(projectRoot)) {
+        console.error(chalk.red('This command must be executed inside a Hexabot project (missing @hexabot-ai/api in package.json).'));
+        console.log(chalk.yellow('Run `hexabot create <project>` or navigate to your project.'));
+        process.exit(1);
+    }
+};
+export const resolveDockerFolder = (projectRoot = process.cwd()) => {
+    return path.resolve(projectRoot, `./${DOCKER_FOLDER_NAME}`);
+};
+export const ensureDockerFolder = (projectRoot = process.cwd()) => {
+    const folder = resolveDockerFolder(projectRoot);
+    if (!fs.existsSync(folder)) {
+        console.error(chalk.red(`The '${DOCKER_FOLDER_NAME}' folder is missing. Docker commands require the Hexabot project's docker/ directory.`));
+        console.log(chalk.yellow(`Ensure you're at the project root (e.g. cd path/to/my-bot) before running Docker commands.`));
+        process.exit(1);
+    }
+    return folder;
+};
+const hasHexabotDependency = (packageJson) => {
+    const allDeps = {
+        ...(packageJson.dependencies || {}),
+        ...(packageJson.devDependencies || {}),
+    };
+    return Boolean(allDeps[HEXABOT_PACKAGE]);
+};

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { createCliProgram } from './cli.js';
+import { checkPrerequisites } from './core/prerequisites.js';
+import { printBanner } from './ui/banner.js';
+printBanner();
+checkPrerequisites({ silent: true });
+const program = createCliProgram();
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/services/templates.js

@@ -0,0 +1,27 @@
+/*
+ * 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 axios from 'axios';
+import decompress from 'decompress';
+export const downloadAndExtractTemplate = async (templateUrl, destination) => {
+    try {
+        const response = await axios({
+            url: templateUrl,
+            method: 'GET',
+            responseType: 'arraybuffer',
+        });
+        const zipFilePath = path.join(destination, 'template.zip');
+        fs.writeFileSync(zipFilePath, response.data);
+        await decompress(zipFilePath, destination, {
+            strip: 1,
+        });
+        fs.unlinkSync(zipFilePath);
+    }
+    catch (_error) {
+        throw new Error(`Failed to download template from GitHub`);
+    }
+};

package/dist/ui/banner.js

@@ -0,0 +1,14 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { getCliVersion } from '../utils/version.js';
+export const printBanner = () => {
+    const bannerText = chalk.blue(figlet.textSync('Hexabot'));
+    const versionText = chalk.gray(`CLI v${getCliVersion()}`);
+    console.log(bannerText);
+    console.log(versionText);
+};

package/dist/utils/__tests__/services.test.js

@@ -0,0 +1,18 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { parseServices } from '../services.js';
+describe('parseServices', () => {
+    it('splits and trims comma separated values', () => {
+        expect(parseServices('api, postgres,worker')).toEqual([
+            'api',
+            'postgres',
+            'worker',
+        ]);
+    });
+    it('filters out empty service values', () => {
+        expect(parseServices(' , , ')).toEqual([]);
+    });
+});

package/dist/utils/__tests__/validation.test.js

@@ -0,0 +1,17 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import { validateProjectName } from '../validation.js';
+describe('validateProjectName', () => {
+    it('accepts lowercase alphanumeric names with dashes', () => {
+        expect(validateProjectName('hexabot-bot01')).toBe(true);
+    });
+    it('rejects names that do not start with a letter', () => {
+        expect(validateProjectName('1hexabot')).toBe(false);
+    });
+    it('rejects names containing uppercase characters or spaces', () => {
+        expect(validateProjectName('Hexabot Agent')).toBe(false);
+    });
+});

package/dist/utils/__tests__/version.test.js

@@ -0,0 +1,27 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+import fs from 'fs';
+import * as path from 'path';
+import { jest } from '@jest/globals';
+import { getCliVersion } from '../version.js';
+describe('getCliVersion', () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('returns the version from the package.json file', () => {
+        const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+        const { version } = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        expect(getCliVersion()).toBe(version);
+    });
+    it('falls back to the default version when package.json cannot be read', () => {
+        const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        const failingReader = () => {
+            throw new Error('file error');
+        };
+        expect(getCliVersion(failingReader)).toBe('3.0.0');
+        expect(errorSpy).toHaveBeenCalled();
+    });
+});

package/dist/utils/services.js

@@ -0,0 +1,11 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export const parseServices = (serviceString) => {
+    return serviceString
+        .split(',')
+        .map((service) => service.trim())
+        .filter((s) => s);
+};

package/dist/utils/validation.js

@@ -0,0 +1,9 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+export const validateProjectName = (projectName) => {
+    const regex = /^[a-z][a-z0-9\-]+$/;
+    return regex.test(projectName);
+};

package/dist/utils/version.js

@@ -0,0 +1,22 @@
+/*
+ * 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 { fileURLToPath } from 'url';
+const INITIAL_CLI_VERSION = '3.0.0';
+export const getCliVersion = (readFile = fs.readFileSync) => {
+    try {
+        const filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(filename);
+        const packageJsonPath = path.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFile(packageJsonPath, 'utf-8'));
+        return packageJson.version;
+    }
+    catch (error) {
+        console.error('Error reading package.json:', error);
+        return INITIAL_CLI_VERSION;
+    }
+};

package/eslint.config-staged.cjs

@@ -0,0 +1,10 @@
+const baseConfig = require('./eslint.config.cjs');
+
+const createConfig =
+  typeof baseConfig.createConfig === 'function'
+    ? baseConfig.createConfig
+    : () => baseConfig;
+
+module.exports = createConfig({
+  headerYear: String(new Date().getFullYear()),
+});