@elsikora/git-branch-lint 1.1.0 → 1.1.1-dev.1

package/bin/index.js

@@ -1,191 +1,111 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
-import { execSync, exec } from 'node:child_process';
-import inquirer from 'inquirer';
 import { cosmiconfig } from 'cosmiconfig';
+import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
+import inquirer from 'inquirer';
 import chalk from 'chalk';
 
 /**
- * Default configuration for branch linting
+ * Base error class for branch creation errors
  */
-const DEFAULT_CONFIG = {
-    branches: {
-        bugfix: { description: "🐞 Fixing issues in existing functionality", title: "Bugfix" },
-        feature: { description: "🆕 Integration of new functionality", title: "Feature" },
-        hotfix: { description: "🚑 Critical fixes for urgent issues", title: "Hotfix" },
-        release: { description: "📦 Preparing a new release version", title: "Release" },
-        support: { description: "🛠️ Support and maintenance tasks", title: "Support" },
-    },
-    ignore: ["dev"],
-    rules: {
-        "branch-max-length": 50,
-        "branch-min-length": 5,
-        "branch-pattern": ":type/:name",
-        "branch-prohibited": ["main", "master", "release"],
-        "branch-subject-pattern": "[a-z0-9-]+",
-    },
-};
+class BranchCreationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BranchCreationError";
+    }
+}
 /**
- * Cosmiconfig implementation of ConfigRepository
+ * Error thrown when trying to create a branch that already exists
  */
-class CosmiconfigRepository {
-    /**
-     * Get the branch configuration
-     * @param appName The name of the application
-     * @returns A promise that resolves to the branch configuration
-     */
-    async getConfig(appName) {
-        const configExplorer = cosmiconfig(appName, {
-            packageProp: `elsikora.${appName}`,
-            searchPlaces: ["package.json", `.elsikora/.${appName}rc`, `.elsikora/.${appName}rc.json`, `.elsikora/.${appName}rc.yaml`, `.elsikora/.${appName}rc.yml`, `.elsikora/.${appName}rc.js`, `.elsikora/.${appName}rc.ts`, `.elsikora/.${appName}rc.mjs`, `.elsikora/.${appName}rc.cjs`, `.elsikora/${appName}.config.js`, `.elsikora/${appName}.config.ts`, `.elsikora/${appName}.config.mjs`, `.elsikora/${appName}.config.cjs`],
-        });
-        const result = await configExplorer.search();
-        if (!result || result.isEmpty) {
-            return DEFAULT_CONFIG;
-        }
-        // Convert the config to match our interfaces
-        const providedConfig = result.config;
-        const mergedConfig = {
-            ...DEFAULT_CONFIG,
-            ...providedConfig,
-        };
-        return mergedConfig;
+class BranchAlreadyExistsError extends BranchCreationError {
+    constructor(branchName) {
+        super(`You are already on branch ${branchName}!`);
+        this.name = "BranchAlreadyExistsError";
     }
 }
-
-const EMPTY_SPACING_OFFSET = 5; // in spaces
-// Функция для выравнивания текста
-const alignChoices = (branchList) => {
-    if (Array.isArray(branchList)) {
-        return branchList.map((branchName) => {
-            return {
-                name: branchName,
-                short: branchName,
-                value: branchName,
-            };
-        });
+/**
+ * Error thrown when git operation fails
+ */
+class GitOperationError extends BranchCreationError {
+    constructor(operation, details) {
+        const message = details ? `Git operation failed: ${operation} - ${details}` : `Git operation failed: ${operation}`;
+        super(message);
+        this.name = "GitOperationError";
     }
-    else {
-        const nameOfBranchesArray = Object.keys(branchList);
-        const maxNameLength = Math.max(...nameOfBranchesArray.map((branchName) => branchName.length));
-        // Формируем choices с выравниванием
-        return nameOfBranchesArray.map((branchName) => {
-            const padding = " ".repeat(maxNameLength - branchName.length + EMPTY_SPACING_OFFSET);
-            return {
-                name: `${branchList[branchName].title}:${padding}${branchList[branchName].description}`,
-                short: branchList[branchName].title,
-                value: branchName,
-            };
-        });
+}
+/**
+ * Error thrown when working directory has uncommitted changes
+ */
+class UncommittedChangesError extends BranchCreationError {
+    constructor() {
+        super("You have uncommitted changes. Please commit or stash them before creating a new branch.");
+        this.name = "UncommittedChangesError";
     }
-};
-
-const branchNameQuiz = async (branchList) => {
-    const { branchType } = await inquirer.prompt([
-        {
-            choices: alignChoices(branchList),
-            message: "Select the type of branch you're creating:",
-            name: "branchType",
-            type: "list",
-        },
-    ]);
-    const { branchName } = await inquirer.prompt([
-        {
-            message: "Enter the branch name (e.g., authorization):",
-            name: "branchName",
-            type: "input",
-            // Валидация названия ветки
-            // eslint-disable-next-line @elsikora/sonar/function-return-type
-            validate: (input) => {
-                if (!input.trim()) {
-                    return "Branch name cannot be empty!";
-                }
-                if (!/^[a-z0-9-]+$/.test(input)) {
-                    return "Branch name can only contain lowercase letters, numbers, and hyphens!";
-                }
-                return true;
-            },
-        },
-    ]);
-    const fullBranchName = `${branchType}/${branchName}`;
-    console.log(`\n⌛️ Creating branch: ${fullBranchName}`);
-    return fullBranchName;
-};
+}
 
-/* eslint-disable @elsikora/sonar/os-command */
-/* eslint-disable @elsikora/unicorn/no-process-exit */
-// Функция для выполнения Git-команд
-const runGitCommand = (command) => {
-    try {
-        execSync(command, { stdio: "inherit" });
-    }
-    catch (error) {
-        console.error(`❌ Error executing command: ${command}`);
-        console.error(error.message);
-        process.exit(1);
+/**
+ * Use case for checking working directory status
+ */
+class CheckWorkingDirectoryUseCase {
+    branchRepository;
+    constructor(branchRepository) {
+        this.branchRepository = branchRepository;
     }
-};
-
-/* eslint-disable @elsikora/sonar/no-os-command-from-path */
-/* eslint-disable @elsikora/unicorn/no-process-exit */
-/* eslint-disable @elsikora/node/no-extraneous-import */
-// Основная функция для создания ветки
-const createBranch = async (appName) => {
-    const configRepository = new CosmiconfigRepository();
-    const { branches } = await configRepository.getConfig(appName);
-    // Проверка чистоты рабочей директории (есть ли незакомиченные файлы)
-    const status = execSync("git status --porcelain", { encoding: "utf8" });
-    if (status) {
-        console.log("⚠️ You have uncommitted changes. Please commit or stash them before creating a new branch.");
-        process.exit(1);
+    /**
+     * Execute the use case
+     * @throws {UncommittedChangesError} When there are uncommitted changes
+     */
+    async execute() {
+        const hasChanges = await this.branchRepository.hasUncommittedChanges();
+        if (hasChanges) {
+            throw new UncommittedChangesError();
+        }
     }
-    //
-    console.log("🌿 Creating a new branch...\n");
-    const branchName = await branchNameQuiz(branches);
-    // Проверка, не создается ли дубликат
-    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
-    if (currentBranch === branchName) {
-        console.log(`⚠️ You are already on branch ${branchName}!`);
-        process.exit(0);
-    }
-    runGitCommand(`git checkout -b ${branchName}`);
-    const { shouldPush } = await inquirer.prompt([
-        {
-            default: false,
-            message: "Do you want to push the branch to the remote repository?",
-            name: "shouldPush",
-            type: "confirm",
-        },
-    ]);
-    if (shouldPush) {
-        runGitCommand(`git push --set-upstream origin ${branchName}`);
-        console.log(`✅ Branch ${branchName} pushed to remote repository!`);
+}
+
+/**
+ * Use case for creating a new branch
+ */
+class CreateBranchUseCase {
+    branchRepository;
+    constructor(branchRepository) {
+        this.branchRepository = branchRepository;
     }
-    else {
-        console.log(`✅ Branch ${branchName} created locally!`);
+    /**
+     * Execute the use case
+     * @param branchName The name of the branch to create
+     * @throws {BranchAlreadyExistsError} When trying to create current branch
+     */
+    async execute(branchName) {
+        const currentBranch = await this.branchRepository.getCurrentBranchName();
+        if (currentBranch === branchName) {
+            throw new BranchAlreadyExistsError(branchName);
+        }
+        await this.branchRepository.createBranch(branchName);
     }
-};
+}
 
 /**
- * Use case for getting branch configuration
+ * Use case for retrieving branch configuration
  */
 class GetBranchConfigUseCase {
-    CONFIG_REPOSITORY;
-    /**
-     * Constructor
-     * @param configRepository The configuration repository
-     */
+    configRepository;
     constructor(configRepository) {
-        this.CONFIG_REPOSITORY = configRepository;
+        this.configRepository = configRepository;
     }
     /**
      * Execute the use case
-     * @param appName The application name
+     * @param appName - The application name
      * @returns The branch configuration
      */
     async execute(appName) {
-        return this.CONFIG_REPOSITORY.getConfig(appName);
+        try {
+            return await this.configRepository.getConfig(appName);
+        }
+        catch (error) {
+            throw new Error(`Failed to get branch config: ${error.message}`);
+        }
     }
 }
 
@@ -252,7 +172,6 @@ class LintError extends Error {
  */
 class BranchTooLongError extends LintError {
     constructor(branchName, maxLength) {
-        // eslint-disable-next-line @elsikora/typescript/restrict-template-expressions
         super(`Branch name "${branchName}" is too long (maximum length: ${maxLength})`);
         this.name = "BranchTooLongError";
     }
@@ -262,7 +181,6 @@ class BranchTooLongError extends LintError {
  */
 class BranchTooShortError extends LintError {
     constructor(branchName, minLength) {
-        // eslint-disable-next-line @elsikora/typescript/restrict-template-expressions
         super(`Branch name "${branchName}" is too short (minimum length: ${minLength})`);
         this.name = "BranchTooShortError";
     }
@@ -287,11 +205,11 @@ class ProhibitedBranchError extends LintError {
 }
 
 /**
- * Use case for linting a branch name
+ * Use case for linting branch names
  */
 class LintBranchNameUseCase {
     /**
-     * Lint a branch name against a configuration
+     * Execute the use case
      * @param branchName The branch name to lint
      * @param config The branch configuration
      * @throws {ProhibitedBranchError} When branch name is prohibited
@@ -301,7 +219,7 @@ class LintBranchNameUseCase {
      */
     execute(branchName, config) {
         const branch = new Branch(branchName);
-        const configRules = config.rules;
+        const configRules = config.rules ?? {};
         const ignoreList = config.ignore ?? [];
         if (configRules?.["branch-prohibited"] && branch.isProhibited(configRules["branch-prohibited"])) {
             throw new ProhibitedBranchError(branchName);
@@ -330,8 +248,10 @@ class LintBranchNameUseCase {
         if (!branchNamePattern) {
             return;
         }
+        // Get branch types - handle both array and object formats
+        const branchTypes = Array.isArray(config.branches) ? config.branches : Object.keys(config.branches);
         const parameters = {
-            type: Object.keys(config.branches),
+            type: branchTypes,
             // Если branch-name-pattern не определён, не добавляем name в params
             ...(subjectNamePattern && { name: [subjectNamePattern] }),
         };
@@ -364,19 +284,342 @@ class LintBranchNameUseCase {
     }
 }
 
+/**
+ * Use case for pushing a branch to remote repository
+ */
+class PushBranchUseCase {
+    branchRepository;
+    constructor(branchRepository) {
+        this.branchRepository = branchRepository;
+    }
+    /**
+     * Execute the use case
+     * @param branchName The name of the branch to push
+     */
+    async execute(branchName) {
+        await this.branchRepository.pushBranch(branchName);
+    }
+}
+
+/**
+ * Default configuration for branch linting
+ */
+const DEFAULT_CONFIG = {
+    branches: {
+        bugfix: { description: "🐞 Fixing issues in existing functionality", title: "Bugfix" },
+        feature: { description: "🆕 Integration of new functionality", title: "Feature" },
+        hotfix: { description: "🚑 Critical fixes for urgent issues", title: "Hotfix" },
+        release: { description: "📦 Preparing a new release version", title: "Release" },
+        support: { description: "🛠️ Support and maintenance tasks", title: "Support" },
+    },
+    ignore: ["dev"],
+    rules: {
+        "branch-max-length": 50,
+        "branch-min-length": 5,
+        "branch-pattern": ":type/:name",
+        "branch-prohibited": ["main", "master", "release"],
+        "branch-subject-pattern": "[a-z0-9-]+",
+    },
+};
+/**
+ * Cosmiconfig implementation of ConfigRepository
+ */
+class CosmiconfigRepository {
+    /**
+     * Get the branch configuration
+     * @param appName The name of the application
+     * @returns A promise that resolves to the branch configuration
+     */
+    async getConfig(appName) {
+        const configExplorer = cosmiconfig(appName, {
+            packageProp: `elsikora.${appName}`,
+            searchPlaces: ["package.json", `.elsikora/.${appName}rc`, `.elsikora/.${appName}rc.json`, `.elsikora/.${appName}rc.yaml`, `.elsikora/.${appName}rc.yml`, `.elsikora/.${appName}rc.js`, `.elsikora/.${appName}rc.ts`, `.elsikora/.${appName}rc.mjs`, `.elsikora/.${appName}rc.cjs`, `.elsikora/${appName}.config.js`, `.elsikora/${appName}.config.ts`, `.elsikora/${appName}.config.mjs`, `.elsikora/${appName}.config.cjs`],
+        });
+        const result = await configExplorer.search();
+        if (!result || result.isEmpty) {
+            return DEFAULT_CONFIG;
+        }
+        // Convert the config to match our interfaces
+        const providedConfig = result.config;
+        const mergedConfig = {
+            ...DEFAULT_CONFIG,
+            ...providedConfig,
+        };
+        return mergedConfig;
+    }
+}
+
 const execAsync = promisify(exec);
 /**
  * Git implementation of BranchRepository
  */
 class GitBranchRepository {
+    /**
+     * Create a new branch
+     * @param branchName The name of the branch to create
+     */
+    async createBranch(branchName) {
+        try {
+            const command = `git checkout -b ${branchName}`;
+            await execAsync(command);
+        }
+        catch (error) {
+            throw new GitOperationError("create branch", error.message);
+        }
+    }
     /**
      * Get the current branch name
      * @returns A promise that resolves to the current branch name
      */
     async getCurrentBranchName() {
-        const command = "git rev-parse --abbrev-ref HEAD";
-        const { stdout } = await execAsync(command);
-        return stdout.trim();
+        try {
+            const command = "git rev-parse --abbrev-ref HEAD";
+            const { stdout } = await execAsync(command);
+            return stdout.trim();
+        }
+        catch (error) {
+            throw new GitOperationError("get current branch", error.message);
+        }
+    }
+    /**
+     * Check if working directory has uncommitted changes
+     * @returns A promise that resolves to true if there are uncommitted changes
+     */
+    async hasUncommittedChanges() {
+        try {
+            const command = "git status --porcelain";
+            const { stdout } = await execAsync(command);
+            return stdout.trim().length > 0;
+        }
+        catch (error) {
+            throw new GitOperationError("check working directory status", error.message);
+        }
+    }
+    /**
+     * Push branch to remote repository
+     * @param branchName The name of the branch to push
+     */
+    async pushBranch(branchName) {
+        try {
+            const command = `git push --set-upstream origin ${branchName}`;
+            await execAsync(command);
+        }
+        catch (error) {
+            throw new GitOperationError("push branch", error.message);
+        }
+    }
+}
+
+/**
+ * Use case for validating branch name format
+ */
+class ValidateBranchNameUseCase {
+    BRANCH_NAME_PATTERN = /^[a-z0-9-]+$/;
+    /**
+     * Execute the use case
+     * @param branchName The branch name to validate
+     * @returns Validation result with error message if invalid
+     */
+    execute(branchName) {
+        if (!branchName.trim()) {
+            return {
+                errorMessage: "Branch name cannot be empty!",
+                isValid: false,
+            };
+        }
+        if (!this.BRANCH_NAME_PATTERN.test(branchName)) {
+            return {
+                errorMessage: "Branch name can only contain lowercase letters, numbers, and hyphens!",
+                isValid: false,
+            };
+        }
+        return { isValid: true };
+    }
+}
+
+/**
+ * Formatter for branch choices in CLI prompts
+ */
+class BranchChoiceFormatter {
+    // eslint-disable-next-line @elsikora/typescript/no-magic-numbers
+    EMPTY_SPACING_OFFSET = 5;
+    /**
+     * Format branch list for CLI selection
+     * @param branchList The list of branches to format
+     * @returns Formatted choices for inquirer prompt
+     */
+    format(branchList) {
+        if (Array.isArray(branchList)) {
+            return this.formatSimpleList(branchList);
+        }
+        return this.formatDetailedList(branchList);
+    }
+    /**
+     * Format detailed branch list (object with descriptions)
+     */
+    formatDetailedList(branchList) {
+        const branchNames = Object.keys(branchList);
+        const maxNameLength = Math.max(...branchNames.map((name) => name.length));
+        return branchNames.map((branchName) => {
+            const branch = branchList[branchName];
+            const padding = " ".repeat(maxNameLength - branchName.length + this.EMPTY_SPACING_OFFSET);
+            return {
+                name: `${branch.title}:${padding}${branch.description}`,
+                short: branch.title,
+                value: branchName,
+            };
+        });
+    }
+    /**
+     * Format simple branch list (array of strings)
+     */
+    formatSimpleList(branchList) {
+        return branchList.map((branchName) => ({
+            name: branchName,
+            short: branchName,
+            value: branchName,
+        }));
+    }
+}
+
+/**
+ * Prompt service for branch creation interactions
+ */
+class BranchCreationPrompt {
+    BRANCH_CHOICE_FORMATTER;
+    VALIDATE_BRANCH_NAME_USE_CASE;
+    constructor() {
+        this.BRANCH_CHOICE_FORMATTER = new BranchChoiceFormatter();
+        this.VALIDATE_BRANCH_NAME_USE_CASE = new ValidateBranchNameUseCase();
+    }
+    /**
+     * Prompt for branch name
+     * @returns Branch name
+     */
+    async promptBranchName() {
+        const result = await inquirer.prompt([
+            {
+                message: "Enter the branch name (e.g., authorization):",
+                name: "branchName",
+                type: "input",
+                // eslint-disable-next-line @elsikora/sonar/function-return-type
+                validate: (input) => {
+                    const validation = this.VALIDATE_BRANCH_NAME_USE_CASE.execute(input);
+                    if (validation.isValid) {
+                        return true;
+                    }
+                    return validation.errorMessage ?? "Invalid branch name";
+                },
+            },
+        ]);
+        return result.branchName;
+    }
+    /**
+     * Prompt for branch type selection
+     * @param branches Available branch types
+     * @returns Selected branch type
+     */
+    async promptBranchType(branches) {
+        const choices = this.BRANCH_CHOICE_FORMATTER.format(branches);
+        const result = await inquirer.prompt([
+            {
+                choices,
+                message: "Select the type of branch you're creating:",
+                name: "branchType",
+                type: "list",
+            },
+        ]);
+        return result.branchType;
+    }
+    /**
+     * Prompt to push branch to remote
+     * @returns Whether to push the branch
+     */
+    async promptPushBranch() {
+        const result = await inquirer.prompt([
+            {
+                // eslint-disable-next-line @elsikora/typescript/naming-convention
+                default: false,
+                message: "Do you want to push the branch to the remote repository?",
+                name: "shouldPush",
+                type: "confirm",
+            },
+        ]);
+        return result.shouldPush;
+    }
+}
+
+/**
+ * Controller for branch creation CLI operations
+ */
+class CreateBranchController {
+    BRANCH_CREATION_PROMPT;
+    CHECK_WORKING_DIRECTORY_USE_CASE;
+    CREATE_BRANCH_USE_CASE;
+    GET_BRANCH_CONFIG_USE_CASE;
+    PUSH_BRANCH_USE_CASE;
+    constructor(checkWorkingDirectoryUseCase, createBranchUseCase, getBranchConfigUseCase, pushBranchUseCase) {
+        this.CHECK_WORKING_DIRECTORY_USE_CASE = checkWorkingDirectoryUseCase;
+        this.CREATE_BRANCH_USE_CASE = createBranchUseCase;
+        this.GET_BRANCH_CONFIG_USE_CASE = getBranchConfigUseCase;
+        this.PUSH_BRANCH_USE_CASE = pushBranchUseCase;
+        this.BRANCH_CREATION_PROMPT = new BranchCreationPrompt();
+    }
+    /**
+     * Execute the branch creation flow
+     * @param appName The application name for configuration
+     */
+    async execute(appName) {
+        try {
+            // Check working directory
+            await this.CHECK_WORKING_DIRECTORY_USE_CASE.execute();
+            console.error("🌿 Creating a new branch...\n");
+            // Get configuration
+            const config = await this.GET_BRANCH_CONFIG_USE_CASE.execute(appName);
+            // Prompt for branch details
+            const branchType = await this.BRANCH_CREATION_PROMPT.promptBranchType(config.branches);
+            const branchName = await this.BRANCH_CREATION_PROMPT.promptBranchName();
+            const fullBranchName = `${branchType}/${branchName}`;
+            console.error(`\n⌛️ Creating branch: ${fullBranchName}`);
+            // Create the branch
+            await this.CREATE_BRANCH_USE_CASE.execute(fullBranchName);
+            // Ask about pushing to remote
+            const shouldPush = await this.BRANCH_CREATION_PROMPT.promptPushBranch();
+            if (shouldPush) {
+                await this.PUSH_BRANCH_USE_CASE.execute(fullBranchName);
+                console.error(`✅ Branch ${fullBranchName} pushed to remote repository!`);
+            }
+            else {
+                console.error(`✅ Branch ${fullBranchName} created locally!`);
+            }
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Handle errors that occur during branch creation
+     * @param error The error that occurred
+     */
+    handleError(error) {
+        if (error instanceof UncommittedChangesError) {
+            console.error(`⚠️ ${error.message}`);
+            // eslint-disable-next-line @elsikora/unicorn/no-process-exit
+            process.exit(1);
+        }
+        if (error instanceof BranchAlreadyExistsError) {
+            console.error(`⚠️ ${error.message}`);
+            // eslint-disable-next-line @elsikora/unicorn/no-process-exit
+            process.exit(0);
+        }
+        if (error instanceof BranchCreationError) {
+            console.error(`❌ ${error.message}`);
+            // eslint-disable-next-line @elsikora/unicorn/no-process-exit
+            process.exit(1);
+        }
+        console.error(`❌ Failed to create branch: ${error.message}`);
+        // eslint-disable-next-line @elsikora/unicorn/no-process-exit
+        process.exit(1);
     }
 }
 
@@ -440,9 +683,9 @@ class HintFormatter {
 }
 
 /**
- * Controller for CLI operations
+ * Controller for linting CLI operations
  */
-class CliController {
+class LintController {
     ERROR_FORMATTER;
     GET_BRANCH_CONFIG_USE_CASE;
     GET_CURRENT_BRANCH_USE_CASE;
@@ -488,7 +731,7 @@ class CliController {
                 // Get the configuration using the service instead of hardcoded values
                 const config = await this.GET_BRANCH_CONFIG_USE_CASE.execute("git-branch-lint");
                 console.error(this.ERROR_FORMATTER.format(error.message));
-                console.log(this.HINT_FORMATTER.format(error, config));
+                console.error(this.HINT_FORMATTER.format(error, config));
                 // Since this is a CLI tool, it's appropriate to exit the process on validation errors
                 // ESLint wants us to throw instead, but this is a CLI application where exit is acceptable
                 // eslint-disable-next-line @elsikora/unicorn/no-process-exit
@@ -509,7 +752,8 @@ class CliController {
  * Application name used for configuration
  */
 const APP_NAME = "git-branch-lint";
-const argv = yargs(process.argv.slice(2))
+const ARGS_SLICE_INDEX = 2;
+const argv = yargs(process.argv.slice(ARGS_SLICE_INDEX))
     .option("branch", {
     alias: "b",
     description: "Run branch creation tool",
@@ -522,28 +766,28 @@ const argv = yargs(process.argv.slice(2))
  * Main function that bootstraps the application
  */
 const main = async () => {
-    if (argv.branch) {
-        try {
-            await createBranch(APP_NAME);
-        }
-        catch (error) {
-            console.error("❌ Failed to create branch:", error.message);
-            // eslint-disable-next-line @elsikora/unicorn/no-process-exit
-            process.exit(1);
-        }
+    // Infrastructure layer
+    const configRepository = new CosmiconfigRepository();
+    const branchRepository = new GitBranchRepository();
+    // Application layer - common use cases
+    const getBranchConfigUseCase = new GetBranchConfigUseCase(configRepository);
+    const shouldRunBranch = Boolean(argv.branch);
+    if (shouldRunBranch) {
+        // Application layer - branch creation use cases
+        const checkWorkingDirectoryUseCase = new CheckWorkingDirectoryUseCase(branchRepository);
+        const createBranchUseCase = new CreateBranchUseCase(branchRepository);
+        const pushBranchUseCase = new PushBranchUseCase(branchRepository);
+        // Presentation layer
+        const createBranchController = new CreateBranchController(checkWorkingDirectoryUseCase, createBranchUseCase, getBranchConfigUseCase, pushBranchUseCase);
+        await createBranchController.execute(APP_NAME);
     }
     else {
-        // Infrastructure layer
-        const configRepository = new CosmiconfigRepository();
-        const branchRepository = new GitBranchRepository();
-        // Application layer
-        const getBranchConfigUseCase = new GetBranchConfigUseCase(configRepository);
+        // Application layer - linting use cases
         const getCurrentBranchUseCase = new GetCurrentBranchUseCase(branchRepository);
         const lintBranchNameUseCase = new LintBranchNameUseCase();
         // Presentation layer
-        const cliController = new CliController(getBranchConfigUseCase, getCurrentBranchUseCase, lintBranchNameUseCase);
-        // Execute the application
-        await cliController.execute(APP_NAME);
+        const lintController = new LintController(getBranchConfigUseCase, getCurrentBranchUseCase, lintBranchNameUseCase);
+        await lintController.execute(APP_NAME);
     }
 };
 // Bootstrap the application and handle errors