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

package/bin/index.js

@@ -1,28 +1,111 @@
 #!/usr/bin/env node
+import yargs from 'yargs';
 import { cosmiconfig } from 'cosmiconfig';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
+import inquirer from 'inquirer';
 import chalk from 'chalk';
 
 /**
- * Use case for getting branch configuration
+ * Base error class for branch creation errors
  */
-class GetBranchConfigUseCase {
-    CONFIG_REPOSITORY;
+class BranchCreationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BranchCreationError";
+    }
+}
+/**
+ * Error thrown when trying to create a branch that already exists
+ */
+class BranchAlreadyExistsError extends BranchCreationError {
+    constructor(branchName) {
+        super(`You are already on branch ${branchName}!`);
+        this.name = "BranchAlreadyExistsError";
+    }
+}
+/**
+ * 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";
+    }
+}
+/**
+ * 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";
+    }
+}
+
+/**
+ * Use case for checking working directory status
+ */
+class CheckWorkingDirectoryUseCase {
+    branchRepository;
+    constructor(branchRepository) {
+        this.branchRepository = branchRepository;
+    }
     /**
-     * Constructor
-     * @param configRepository The configuration repository
+     * Execute the use case
+     * @throws {UncommittedChangesError} When there are uncommitted changes
      */
+    async execute() {
+        const hasChanges = await this.branchRepository.hasUncommittedChanges();
+        if (hasChanges) {
+            throw new UncommittedChangesError();
+        }
+    }
+}
+
+/**
+ * Use case for creating a new branch
+ */
+class CreateBranchUseCase {
+    branchRepository;
+    constructor(branchRepository) {
+        this.branchRepository = branchRepository;
+    }
+    /**
+     * 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 retrieving branch configuration
+ */
+class GetBranchConfigUseCase {
+    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}`);
+        }
     }
 }
 
@@ -89,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";
     }
@@ -99,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";
     }
@@ -124,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
@@ -138,18 +219,19 @@ class LintBranchNameUseCase {
      */
     execute(branchName, config) {
         const branch = new Branch(branchName);
-        if (branch.isProhibited(config.PROHIBITED)) {
+        const configRules = config.rules ?? {};
+        const ignoreList = config.ignore ?? [];
+        if (configRules?.["branch-prohibited"] && branch.isProhibited(configRules["branch-prohibited"])) {
             throw new ProhibitedBranchError(branchName);
         }
-        // @ts-ignore
-        if (branch.isTooShort(config.MINLENGTH)) {
-            // @ts-ignore
-            throw new BranchTooShortError(branchName, config.MINLENGTH);
+        if (ignoreList.length > 0 && ignoreList.includes(branchName)) {
+            return;
+        }
+        if (configRules?.["branch-min-length"] && branch.isTooShort(configRules["branch-min-length"])) {
+            throw new BranchTooShortError(branchName, configRules["branch-min-length"]);
         }
-        // @ts-ignore
-        if (branch.isTooLong(config.MAXLENGTH)) {
-            // @ts-ignore
-            throw new BranchTooLongError(branchName, config.MAXLENGTH);
+        if (configRules?.["branch-max-length"] && branch.isTooLong(configRules["branch-max-length"])) {
+            throw new BranchTooLongError(branchName, configRules["branch-max-length"]);
         }
         this.validatePattern(branch.getName(), config);
     }
@@ -161,16 +243,24 @@ class LintBranchNameUseCase {
      */
     validatePattern(branchName, config) {
         // Start with original pattern
-        let pattern = config.PATTERN;
-        // Process each parameter in the configuration
-        for (const [key, values] of Object.entries(config.PARAMS)) {
-            // Create the placeholder - IMPORTANT: Convert to lowercase to match pattern
+        let branchNamePattern = config.rules?.["branch-pattern"];
+        const subjectNamePattern = config.rules?.["branch-subject-pattern"];
+        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: branchTypes,
+            // Если branch-name-pattern не определён, не добавляем name в params
+            ...(subjectNamePattern && { name: [subjectNamePattern] }),
+        };
+        // Обрабатываем параметры, если они есть
+        for (const [key, values] of Object.entries(parameters)) {
             const placeholder = `:${key.toLowerCase()}`;
-            const parameterValues = values;
             let replacement = "(";
-            for (let index = 0; index < parameterValues.length; index++) {
-                const value = parameterValues[index];
-                // Add the value to the replacement pattern
+            for (let index = 0; index < values.length; index++) {
+                const value = values[index];
                 if (value.startsWith("[")) {
                     replacement += value;
                 }
@@ -178,17 +268,15 @@ class LintBranchNameUseCase {
                     const escapedValue = value.replaceAll(/[-/\\^$*+?.()|[\]{}]/g, String.raw `\$&`);
                     replacement += escapedValue;
                 }
-                // Add OR separator if not the last value
-                if (index < parameterValues.length - 1) {
+                if (index < values.length - 1) {
                     replacement += "|";
                 }
             }
             replacement += ")";
-            // Replace the placeholder in the pattern
-            pattern = pattern.replaceAll(new RegExp(placeholder, "g"), replacement);
+            branchNamePattern = branchNamePattern.replaceAll(new RegExp(placeholder, "g"), replacement);
         }
         // Create the regular expression
-        const regexp = new RegExp(`^${pattern}$`);
+        const regexp = new RegExp(`^${branchNamePattern}$`);
         // Test the branch name against the pattern
         if (!regexp.test(branchName)) {
             throw new PatternMatchError(branchName);
@@ -196,20 +284,42 @@ 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 = {
-    // eslint-disable-next-line @elsikora-typescript/no-magic-numbers
-    MAXLENGTH: 50,
-    // eslint-disable-next-line @elsikora-typescript/no-magic-numbers
-    MINLENGTH: 5,
-    PARAMS: {
-        NAME: ["[a-z0-9-]+"],
-        TYPE: ["feature", "hotfix", "support", "bugfix", "release"],
+    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-]+",
     },
-    PATTERN: ":type/:name",
-    PROHIBITED: ["ci", "wip", "main", "test", "build", "master", "release", "dev", "develop"],
 };
 /**
  * Cosmiconfig implementation of ConfigRepository
@@ -231,47 +341,10 @@ class CosmiconfigRepository {
         }
         // Convert the config to match our interfaces
         const providedConfig = result.config;
-        const uppercasedConfig = {};
-        // Create a new object with uppercase keys instead of modifying the original
-        for (const key of Object.keys(providedConfig)) {
-            const uppercaseKey = key.toUpperCase();
-            const value = providedConfig[key];
-            if (Array.isArray(value)) {
-                // Preserve arrays
-                // eslint-disable-next-line @elsikora-typescript/no-unsafe-assignment
-                uppercasedConfig[uppercaseKey] = [...value];
-            }
-            else if (typeof value === "object" && value !== null) {
-                // Handle nested objects
-                const nestedObject = {};
-                for (const subKey of Object.keys(value)) {
-                    const subValue = value[subKey];
-                    if (Array.isArray(subValue)) {
-                        // Preserve nested arrays
-                        // eslint-disable-next-line @elsikora-typescript/no-unsafe-assignment
-                        nestedObject[subKey.toUpperCase()] = [...subValue];
-                    }
-                    else {
-                        nestedObject[subKey.toUpperCase()] = subValue;
-                    }
-                }
-                uppercasedConfig[uppercaseKey] = nestedObject;
-            }
-            else {
-                // Handle primitive values
-                uppercasedConfig[uppercaseKey] = value;
-            }
-        }
         const mergedConfig = {
             ...DEFAULT_CONFIG,
-            ...uppercasedConfig,
+            ...providedConfig,
         };
-        if (uppercasedConfig.PARAMS && DEFAULT_CONFIG.PARAMS) {
-            mergedConfig.PARAMS = {
-                ...DEFAULT_CONFIG.PARAMS,
-                ...uppercasedConfig.PARAMS,
-            };
-        }
         return mergedConfig;
     }
 }
@@ -281,14 +354,272 @@ 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);
     }
 }
 
@@ -333,12 +664,11 @@ class HintFormatter {
      */
     formatPatternMatchHint(config) {
         let output = "";
-        output += `${chalk.blue("Expected pattern:")} ${chalk.yellow(config.PATTERN)}\n`;
-        // Format the parameters
-        for (const [parameterName, parameterValues] of Object.entries(config.PARAMS)) {
-            const valuesList = parameterValues.map((value) => chalk.yellow(value)).join(", ");
-            output += chalk.blue(`Valid ${parameterName} values:`) + " " + valuesList + "\n";
-        }
+        const branchNamePattern = config.rules?.["branch-pattern"];
+        const branchTypeList = Array.isArray(config.branches) ? config.branches : Object.keys(config.branches);
+        output += branchNamePattern ? `${chalk.blue("Expected pattern:")} ${chalk.yellow(branchNamePattern)}\n` : "";
+        const valuesList = branchTypeList.map((value) => chalk.yellow(value)).join(", ");
+        output += chalk.blue(`Valid branch types:`) + " " + valuesList + "\n";
         return output.trim();
     }
     /**
@@ -347,15 +677,15 @@ class HintFormatter {
      * @returns The formatted hint
      */
     formatProhibitedBranchHint(config) {
-        const prohibitedList = config.PROHIBITED.map((name) => chalk.yellow(name)).join(", ");
+        const prohibitedList = config.rules?.["branch-prohibited"]?.map((name) => chalk.yellow(name)).join(", ") ?? "";
         return `${chalk.blue("Prohibited branch names:")} ${prohibitedList}`;
     }
 }
 
 /**
- * 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;
@@ -401,16 +731,16 @@ 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-node/no-process-exit, @elsikora-unicorn/no-process-exit
+                // eslint-disable-next-line @elsikora/unicorn/no-process-exit
                 process.exit(1);
             }
             catch {
                 console.error(this.ERROR_FORMATTER.format("Failed to load configuration for error hint"));
                 console.error(this.ERROR_FORMATTER.format(error.message));
-                // eslint-disable-next-line elsikora-node/no-process-exit, @elsikora-unicorn/no-process-exit
+                // eslint-disable-next-line @elsikora/unicorn/no-process-exit
                 process.exit(1);
             }
         }
@@ -422,6 +752,16 @@ class CliController {
  * Application name used for configuration
  */
 const APP_NAME = "git-branch-lint";
+const ARGS_SLICE_INDEX = 2;
+const argv = yargs(process.argv.slice(ARGS_SLICE_INDEX))
+    .option("branch", {
+    alias: "b",
+    description: "Run branch creation tool",
+    type: "boolean",
+})
+    .help()
+    .usage("Usage: $0 [-b] to create a branch or lint the current branch")
+    .parseSync();
 /**
  * Main function that bootstraps the application
  */
@@ -429,14 +769,26 @@ const main = async () => {
     // Infrastructure layer
     const configRepository = new CosmiconfigRepository();
     const branchRepository = new GitBranchRepository();
-    // Application layer
+    // Application layer - common use cases
     const getBranchConfigUseCase = new GetBranchConfigUseCase(configRepository);
-    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 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 {
+        // Application layer - linting use cases
+        const getCurrentBranchUseCase = new GetCurrentBranchUseCase(branchRepository);
+        const lintBranchNameUseCase = new LintBranchNameUseCase();
+        // Presentation layer
+        const lintController = new LintController(getBranchConfigUseCase, getCurrentBranchUseCase, lintBranchNameUseCase);
+        await lintController.execute(APP_NAME);
+    }
 };
 // Bootstrap the application and handle errors
 main().catch((error) => {