@elsikora/git-branch-lint 1.2.1-dev.1 → 1.2.2-dev.1

package/bin/index.js

@@ -6,6 +6,126 @@ import { promisify } from 'node:util';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 
+const DEFAULT_BRANCH_SUBJECT_PATTERN_SOURCE = "[a-z0-9-]+";
+
+const TICKET_ID_EXAMPLE = "PROJ-123";
+const TICKET_ID_PATTERN_SOURCE = "[a-z]{2,}-[0-9]+";
+
+const OPTIONAL_PLACEHOLDER_SUFFIXES = ["-"];
+/**
+ * Domain policy for working with branch templates and placeholders.
+ */
+class BranchTemplatePolicy {
+    static PLACEHOLDER_PATTERN = /:([a-z](?:[a-z0-9-]*[a-z0-9])?)/gi;
+    buildBranchName(branchPattern, placeholderValues) {
+        let resolvedBranchName = branchPattern;
+        for (const placeholderName of this.getPlaceholders(branchPattern)) {
+            const placeholderToken = `:${placeholderName}`;
+            const rawValue = placeholderValues[placeholderName] ?? "";
+            const normalizedValue = rawValue.trim();
+            if (normalizedValue.length === 0 && this.isPlaceholderOptional(branchPattern, placeholderName)) {
+                resolvedBranchName = this.removeOptionalPlaceholder(resolvedBranchName, placeholderName);
+                continue;
+            }
+            resolvedBranchName = resolvedBranchName.replaceAll(placeholderToken, normalizedValue);
+        }
+        return this.normalizeBranchNameDelimiters(resolvedBranchName);
+    }
+    buildValidationPatterns(branchPattern) {
+        let patternVariants = [branchPattern];
+        for (const placeholderName of this.getPlaceholders(branchPattern)) {
+            if (!this.isPlaceholderOptional(branchPattern, placeholderName)) {
+                continue;
+            }
+            patternVariants = patternVariants.flatMap((variant) => [variant, this.removeOptionalPlaceholder(variant, placeholderName)]);
+        }
+        return [...new Set(patternVariants.map((variant) => this.normalizeBranchNameDelimiters(variant)).filter((variant) => variant.length > 0))];
+    }
+    getPlaceholders(branchPattern) {
+        const matches = branchPattern.matchAll(BranchTemplatePolicy.PLACEHOLDER_PATTERN);
+        const orderedPlaceholders = [];
+        for (const match of matches) {
+            const placeholderName = match[1];
+            if (!orderedPlaceholders.includes(placeholderName)) {
+                orderedPlaceholders.push(placeholderName);
+            }
+        }
+        return orderedPlaceholders;
+    }
+    isPlaceholderOptional(branchPattern, placeholderName) {
+        const placeholderToken = `:${placeholderName}`;
+        return OPTIONAL_PLACEHOLDER_SUFFIXES.some((suffix) => branchPattern.includes(`${placeholderToken}${suffix}`));
+    }
+    resolvePlaceholderPatternSource(placeholderName, branchTypes, subjectPattern) {
+        if (placeholderName === "type") {
+            return this.createAlternationPattern(branchTypes);
+        }
+        if (typeof subjectPattern === "object" && subjectPattern?.[placeholderName]) {
+            return subjectPattern[placeholderName];
+        }
+        if (placeholderName === "ticket") {
+            return TICKET_ID_PATTERN_SOURCE;
+        }
+        if (typeof subjectPattern === "string") {
+            return subjectPattern;
+        }
+        return DEFAULT_BRANCH_SUBJECT_PATTERN_SOURCE;
+    }
+    createAlternationPattern(branchTypes) {
+        if (branchTypes.length === 0) {
+            return DEFAULT_BRANCH_SUBJECT_PATTERN_SOURCE;
+        }
+        return branchTypes.map((branchType) => this.escapeRegex(branchType)).join("|");
+    }
+    escapeRegex(value) {
+        return value.replaceAll(/[\\^$.*+?()[\]{}|/-]/g, String.raw `\$&`);
+    }
+    isDelimiter(character) {
+        return character === "." || character === "-" || character === "/" || character === "_";
+    }
+    normalizeBranchNameDelimiters(branchName) {
+        const compactedBranchName = branchName
+            .replaceAll(/\/{2,}/g, "/")
+            .replaceAll(/-{2,}/g, "-")
+            .replaceAll(/_{2,}/g, "_")
+            .replaceAll(/\.{2,}/g, ".");
+        return this.trimDelimiterEdges(compactedBranchName);
+    }
+    removeOptionalPlaceholder(branchPattern, placeholderName) {
+        const placeholderToken = `:${placeholderName}`;
+        let updatedPattern = branchPattern;
+        for (const suffix of OPTIONAL_PLACEHOLDER_SUFFIXES) {
+            updatedPattern = updatedPattern.replaceAll(`${placeholderToken}${suffix}`, "");
+        }
+        updatedPattern = updatedPattern.replaceAll(placeholderToken, "");
+        return updatedPattern;
+    }
+    trimDelimiterEdges(value) {
+        let startIndex = 0;
+        let endIndex = value.length - 1;
+        while (startIndex <= endIndex && this.isDelimiter(value[startIndex])) {
+            startIndex++;
+        }
+        while (endIndex >= startIndex && this.isDelimiter(value[endIndex])) {
+            endIndex--;
+        }
+        return value.slice(startIndex, endIndex + 1);
+    }
+}
+
+/**
+ * Use case for assembling a branch name from validated user inputs.
+ */
+class BuildBranchNameUseCase {
+    branchTemplatePolicy;
+    constructor(branchTemplatePolicy = new BranchTemplatePolicy()) {
+        this.branchTemplatePolicy = branchTemplatePolicy;
+    }
+    execute(parameters) {
+        return this.branchTemplatePolicy.buildBranchName(parameters.branchPattern, parameters.placeholderValues);
+    }
+}
+
 /**
  * Base error class for branch creation errors
  */
@@ -109,24 +229,65 @@ class GetBranchConfigUseCase {
     }
 }
 
+/**
+ * Use case for retrieving effective branch pattern.
+ */
+class GetBranchPatternUseCase {
+    DEFAULT_BRANCH_PATTERN = ":type/:name";
+    execute(config) {
+        return config.rules?.["branch-pattern"] ?? this.DEFAULT_BRANCH_PATTERN;
+    }
+}
+
+/**
+ * Use case for resolving placeholder definitions from branch pattern config.
+ */
+class GetBranchPlaceholderDefinitionsUseCase {
+    branchTemplatePolicy;
+    constructor(branchTemplatePolicy = new BranchTemplatePolicy()) {
+        this.branchTemplatePolicy = branchTemplatePolicy;
+    }
+    execute(parameters) {
+        const branchPattern = parameters.config.rules?.["branch-pattern"];
+        const subjectPattern = parameters.config.rules?.["branch-subject-pattern"];
+        if (!branchPattern) {
+            return [];
+        }
+        const branchTypes = Array.isArray(parameters.config.branches) ? parameters.config.branches : Object.keys(parameters.config.branches);
+        const placeholderNames = this.branchTemplatePolicy.getPlaceholders(branchPattern);
+        return placeholderNames.map((placeholderName) => {
+            if (placeholderName === "type") {
+                return {
+                    isOptional: false,
+                    isTypePlaceholder: true,
+                    placeholderName,
+                };
+            }
+            return {
+                ...(placeholderName === "ticket" && { example: TICKET_ID_EXAMPLE }),
+                isOptional: this.branchTemplatePolicy.isPlaceholderOptional(branchPattern, placeholderName),
+                isTypePlaceholder: false,
+                patternSource: this.branchTemplatePolicy.resolvePlaceholderPatternSource(placeholderName, branchTypes, subjectPattern),
+                placeholderName,
+            };
+        });
+    }
+}
+
 /**
  * Use case for getting the current branch name
  */
 class GetCurrentBranchUseCase {
-    BRANCH_REPOSITORY;
-    /**
-     * Constructor
-     * @param branchRepository The branch repository
-     */
+    branchRepository;
     constructor(branchRepository) {
-        this.BRANCH_REPOSITORY = branchRepository;
+        this.branchRepository = branchRepository;
     }
     /**
      * Execute the use case
      * @returns The current branch name
      */
     async execute() {
-        return this.BRANCH_REPOSITORY.getCurrentBranchName();
+        return this.branchRepository.getCurrentBranchName();
     }
 }
 
@@ -185,6 +346,15 @@ class BranchTooShortError extends LintError {
         this.name = "BranchTooShortError";
     }
 }
+/**
+ * Error thrown when a branch placeholder pattern in config is invalid.
+ */
+class InvalidBranchPatternConfigError extends LintError {
+    constructor(placeholderName, patternSource) {
+        super(`Invalid branch pattern config for "${placeholderName}": ${patternSource}`);
+        this.name = "InvalidBranchPatternConfigError";
+    }
+}
 /**
  * Error thrown when branch name doesn't match the pattern
  */
@@ -208,6 +378,10 @@ class ProhibitedBranchError extends LintError {
  * Use case for linting branch names
  */
 class LintBranchNameUseCase {
+    BRANCH_TEMPLATE_POLICY;
+    constructor(branchTemplatePolicy = new BranchTemplatePolicy()) {
+        this.BRANCH_TEMPLATE_POLICY = branchTemplatePolicy;
+    }
     /**
      * Execute the use case
      * @param branchName The branch name to lint
@@ -235,48 +409,6 @@ class LintBranchNameUseCase {
         }
         this.validatePattern(branch.getName(), config);
     }
-    /**
-     * Test a branch name against a specific pattern
-     * @param branchName The branch name to test
-     * @param pattern The pattern to test against
-     * @param branchTypes Available branch types
-     * @param subjectNamePattern Pattern for the name/description part
-     * @returns true if pattern matches
-     */
-    testPattern(branchName, pattern, branchTypes, subjectNamePattern) {
-        let processedPattern = pattern;
-        const parameters = {
-            type: branchTypes,
-            // Add ticket pattern if present (accepts lowercase letters)
-            ...(processedPattern.includes(":ticket") && { ticket: ["[a-z]{2,}-[0-9]+"] }),
-            // Add name pattern if specified
-            ...(subjectNamePattern && { name: [subjectNamePattern] }),
-        };
-        // Process parameters
-        for (const [key, values] of Object.entries(parameters)) {
-            const placeholder = `:${key.toLowerCase()}`;
-            let replacement = "(";
-            for (let index = 0; index < values.length; index++) {
-                const value = values[index];
-                if (value.startsWith("[")) {
-                    replacement += value;
-                }
-                else {
-                    const escapedValue = value.replaceAll(/[-/\\^$*+?.()|[\]{}]/g, String.raw `\$&`);
-                    replacement += escapedValue;
-                }
-                if (index < values.length - 1) {
-                    replacement += "|";
-                }
-            }
-            replacement += ")";
-            processedPattern = processedPattern.replaceAll(new RegExp(placeholder, "g"), replacement);
-        }
-        // Create the regular expression
-        const regexp = new RegExp(`^${processedPattern}$`);
-        // Test the branch name against the pattern
-        return regexp.test(branchName);
-    }
     /**
      * Validate the branch name against the pattern
      * @param branchName The branch name to validate
@@ -286,36 +418,65 @@ class LintBranchNameUseCase {
     validatePattern(branchName, config) {
         // Start with original pattern
         const branchNamePattern = config.rules?.["branch-pattern"];
-        const subjectNamePattern = config.rules?.["branch-subject-pattern"];
+        const subjectPattern = 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);
-        // Check if pattern contains :ticket placeholder
-        const hasTicketPlaceholder = branchNamePattern.includes(":ticket");
-        // Build patterns to try - with ticket and without ticket
-        const patternsToTry = [];
-        if (hasTicketPlaceholder) {
-            // Try pattern with ticket: type/TICKET-123-description
-            // Try pattern without ticket: type/description (replace :ticket- with empty)
-            patternsToTry.push(branchNamePattern, branchNamePattern.replace(":ticket-", ""));
-        }
-        else {
-            // Only one pattern available
-            patternsToTry.push(branchNamePattern);
-        }
-        // Try each pattern
-        for (const patternToTry of patternsToTry) {
-            if (this.testPattern(branchName, patternToTry, branchTypes, subjectNamePattern)) {
-                return; // Pattern matched, validation passed
+        const placeholders = this.BRANCH_TEMPLATE_POLICY.getPlaceholders(branchNamePattern);
+        const patternVariants = this.BRANCH_TEMPLATE_POLICY.buildValidationPatterns(branchNamePattern);
+        for (const patternVariant of patternVariants) {
+            let resolvedPattern = patternVariant;
+            for (const placeholder of placeholders) {
+                const placeholderToken = `:${placeholder}`;
+                if (!resolvedPattern.includes(placeholderToken)) {
+                    continue;
+                }
+                const patternSource = this.BRANCH_TEMPLATE_POLICY.resolvePlaceholderPatternSource(placeholder, branchTypes, subjectPattern);
+                resolvedPattern = resolvedPattern.replaceAll(placeholderToken, `(${patternSource})`);
+            }
+            const expression = new RegExp(`^${resolvedPattern}$`);
+            if (expression.test(branchName)) {
+                return;
             }
         }
-        // No pattern matched
         throw new PatternMatchError(branchName);
     }
 }
 
+/**
+ * Domain policy for ticket identifier normalization and validation.
+ */
+class TicketIdPolicy {
+    static TICKET_ID_PATTERN = new RegExp(`^${TICKET_ID_PATTERN_SOURCE}$`);
+    isEmpty(candidate) {
+        return candidate.trim().length === 0;
+    }
+    isValid(candidate) {
+        const normalizedCandidate = this.normalize(candidate);
+        if (normalizedCandidate.length === 0) {
+            return false;
+        }
+        return TicketIdPolicy.TICKET_ID_PATTERN.test(normalizedCandidate);
+    }
+    normalize(candidate) {
+        return candidate.trim().toLowerCase();
+    }
+}
+
+/**
+ * Use case for normalizing optional ticket identifier input.
+ */
+class NormalizeTicketIdUseCase {
+    ticketIdPolicy;
+    constructor(ticketIdPolicy = new TicketIdPolicy()) {
+        this.ticketIdPolicy = ticketIdPolicy;
+    }
+    execute(ticketId) {
+        return this.ticketIdPolicy.normalize(ticketId);
+    }
+}
+
 /**
  * Use case for pushing a branch to remote repository
  */
@@ -335,10 +496,7 @@ class PushBranchUseCase {
 
 const BRANCH_MAX_LENGTH = 50;
 const BRANCH_MIN_LENGTH = 5;
-/**
- * Default configuration for branch linting
- */
-const DEFAULT_CONFIG = {
+const DEFAULT_BRANCH_LINT_CONFIG = {
     branches: {
         bugfix: { description: "🐞 Fixing issues in existing functionality", title: "Bugfix" },
         feature: { description: "🆕 Integration of new functionality", title: "Feature" },
@@ -355,6 +513,7 @@ const DEFAULT_CONFIG = {
         "branch-subject-pattern": "[a-z0-9-]+",
     },
 };
+
 /**
  * Cosmiconfig implementation of ConfigRepository
  */
@@ -371,13 +530,19 @@ class CosmiconfigRepository {
         });
         const result = await configExplorer.search();
         if (!result || result.isEmpty) {
-            return DEFAULT_CONFIG;
+            return DEFAULT_BRANCH_LINT_CONFIG;
         }
         // Convert the config to match our interfaces
         const providedConfig = result.config;
         const mergedConfig = {
-            ...DEFAULT_CONFIG,
+            ...DEFAULT_BRANCH_LINT_CONFIG,
             ...providedConfig,
+            branches: providedConfig.branches ?? DEFAULT_BRANCH_LINT_CONFIG.branches,
+            ignore: providedConfig.ignore ?? DEFAULT_BRANCH_LINT_CONFIG.ignore,
+            rules: {
+                ...DEFAULT_BRANCH_LINT_CONFIG.rules,
+                ...providedConfig.rules,
+            },
         };
         return mergedConfig;
     }
@@ -445,25 +610,25 @@ class GitBranchRepository {
 }
 
 /**
- * Use case for validating branch name format
+ * Use case for validating interactive placeholder values.
  */
-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,
-            };
+class ValidateBranchPlaceholderValueUseCase {
+    execute(parameters) {
+        const normalizedValue = parameters.value.trim();
+        if (parameters.isOptional && normalizedValue.length === 0) {
+            return { isValid: true };
+        }
+        let expression;
+        try {
+            const flags = parameters.placeholderName === "ticket" ? "i" : "";
+            expression = new RegExp(`^${parameters.patternSource}$`, flags);
         }
-        if (!this.BRANCH_NAME_PATTERN.test(branchName)) {
+        catch {
+            throw new InvalidBranchPatternConfigError(parameters.placeholderName, parameters.patternSource);
+        }
+        if (!expression.test(normalizedValue)) {
             return {
-                errorMessage: "Branch name can only contain lowercase letters, numbers, and hyphens!",
+                errorMessage: `Invalid ${parameters.placeholderName} format`,
                 isValid: false,
             };
         }
@@ -521,31 +686,10 @@ class BranchChoiceFormatter {
  */
 class BranchCreationPrompt {
     BRANCH_CHOICE_FORMATTER;
-    VALIDATE_BRANCH_NAME_USE_CASE;
+    VALIDATE_BRANCH_PLACEHOLDER_VALUE_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",
-                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;
+        this.VALIDATE_BRANCH_PLACEHOLDER_VALUE_USE_CASE = new ValidateBranchPlaceholderValueUseCase();
     }
     /**
      * Prompt for branch type selection
@@ -564,6 +708,37 @@ class BranchCreationPrompt {
         ]);
         return result.branchType;
     }
+    /**
+     * Prompt for a branch placeholder value based on a validation pattern.
+     */
+    async promptPlaceholder(options) {
+        const result = await inquirer.prompt([
+            {
+                message: this.buildPlaceholderPromptMessage(options),
+                name: "value",
+                transformer: (input) => {
+                    if (options.isOptional && input.trim() === "") {
+                        return "\u001B[2m(Enter to skip)\u001B[0m";
+                    }
+                    return input;
+                },
+                type: "input",
+                validate: (input) => {
+                    const validation = this.VALIDATE_BRANCH_PLACEHOLDER_VALUE_USE_CASE.execute({
+                        isOptional: options.isOptional,
+                        patternSource: options.patternSource,
+                        placeholderName: options.placeholderName,
+                        value: input,
+                    });
+                    if (validation.isValid) {
+                        return true;
+                    }
+                    return validation.errorMessage ?? this.buildPlaceholderValidationMessage(options);
+                },
+            },
+        ]);
+        return result.value.trim();
+    }
     /**
      * Prompt to push branch to remote
      * @returns Whether to push the branch
@@ -580,39 +755,15 @@ class BranchCreationPrompt {
         ]);
         return result.shouldPush;
     }
-    /**
-     * Prompt for ticket ID (optional)
-     * @returns Ticket ID in lowercase or empty string if skipped
-     */
-    async promptTicketId() {
-        const result = await inquirer.prompt([
-            {
-                message: "Ticket ID (optional, e.g., PROJ-123):",
-                name: "ticketId",
-                transformer: (input) => {
-                    // Show placeholder when empty
-                    return input.trim() === "" ? "\u001B[2m(Enter to skip)\u001B[0m" : input;
-                },
-                type: "input",
-                validate: (input) => {
-                    // Empty is valid (optional field)
-                    if (!input || input.trim() === "") {
-                        return true;
-                    }
-                    // Normalize input for validation (case-insensitive)
-                    const normalizedInput = input.trim();
-                    // Validate format: 2+ letters (any case), dash, digits
-                    const ticketPattern = /^[A-Z]{2,}-\d+$/i;
-                    if (!ticketPattern.test(normalizedInput)) {
-                        return "Invalid format. Expected format: PROJ-123 (2+ letters, dash, numbers)";
-                    }
-                    return true;
-                },
-            },
-        ]);
-        // Return lowercase version or empty string
-        const trimmed = result.ticketId.trim();
-        return trimmed ? trimmed.toLowerCase() : "";
+    buildPlaceholderPromptMessage(options) {
+        const normalizedPlaceholderName = options.placeholderName.replaceAll("-", " ");
+        const capitalizedPlaceholderName = normalizedPlaceholderName[0].toUpperCase() + normalizedPlaceholderName.slice(1);
+        const optionalPart = options.isOptional ? " optional" : "";
+        const examplePart = options.example ? `, e.g., ${options.example}` : "";
+        return `${capitalizedPlaceholderName}${optionalPart}${examplePart}:`;
+    }
+    buildPlaceholderValidationMessage(options) {
+        return `Invalid ${options.placeholderName} format`;
     }
 }
 
@@ -621,14 +772,24 @@ class BranchCreationPrompt {
  */
 class CreateBranchController {
     BRANCH_CREATION_PROMPT;
+    BUILD_BRANCH_NAME_USE_CASE;
     CHECK_WORKING_DIRECTORY_USE_CASE;
     CREATE_BRANCH_USE_CASE;
     GET_BRANCH_CONFIG_USE_CASE;
+    GET_BRANCH_PATTERN_USE_CASE;
+    GET_BRANCH_PLACEHOLDER_DEFINITIONS_USE_CASE;
+    LINT_BRANCH_NAME_USE_CASE;
+    NORMALIZE_TICKET_ID_USE_CASE;
     PUSH_BRANCH_USE_CASE;
-    constructor(checkWorkingDirectoryUseCase, createBranchUseCase, getBranchConfigUseCase, pushBranchUseCase) {
+    constructor(buildBranchNameUseCase, checkWorkingDirectoryUseCase, createBranchUseCase, getBranchPatternUseCase, getBranchPlaceholderDefinitionsUseCase, getBranchConfigUseCase, lintBranchNameUseCase, normalizeTicketIdUseCase, pushBranchUseCase) {
+        this.BUILD_BRANCH_NAME_USE_CASE = buildBranchNameUseCase;
         this.CHECK_WORKING_DIRECTORY_USE_CASE = checkWorkingDirectoryUseCase;
         this.CREATE_BRANCH_USE_CASE = createBranchUseCase;
         this.GET_BRANCH_CONFIG_USE_CASE = getBranchConfigUseCase;
+        this.GET_BRANCH_PATTERN_USE_CASE = getBranchPatternUseCase;
+        this.GET_BRANCH_PLACEHOLDER_DEFINITIONS_USE_CASE = getBranchPlaceholderDefinitionsUseCase;
+        this.LINT_BRANCH_NAME_USE_CASE = lintBranchNameUseCase;
+        this.NORMALIZE_TICKET_ID_USE_CASE = normalizeTicketIdUseCase;
         this.PUSH_BRANCH_USE_CASE = pushBranchUseCase;
         this.BRANCH_CREATION_PROMPT = new BranchCreationPrompt();
     }
@@ -643,20 +804,28 @@ class CreateBranchController {
             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 ticketId = await this.BRANCH_CREATION_PROMPT.promptTicketId();
-            const branchName = await this.BRANCH_CREATION_PROMPT.promptBranchName();
-            // Build full branch name based on whether ticket ID is provided
-            let fullBranchName;
-            if (ticketId) {
-                // Format: type/TICKET-123-description
-                fullBranchName = `${branchType}/${ticketId}-${branchName}`;
-            }
-            else {
-                // Format: type/description
-                fullBranchName = `${branchType}/${branchName}`;
+            const branchPattern = this.GET_BRANCH_PATTERN_USE_CASE.execute(config);
+            const placeholderDefinitions = this.GET_BRANCH_PLACEHOLDER_DEFINITIONS_USE_CASE.execute({ config });
+            const placeholderValues = {};
+            for (const placeholderDefinition of placeholderDefinitions) {
+                if (placeholderDefinition.isTypePlaceholder) {
+                    placeholderValues.type = await this.BRANCH_CREATION_PROMPT.promptBranchType(config.branches);
+                    continue;
+                }
+                const inputValue = await this.BRANCH_CREATION_PROMPT.promptPlaceholder({
+                    example: placeholderDefinition.example,
+                    isOptional: placeholderDefinition.isOptional,
+                    patternSource: placeholderDefinition.patternSource ?? "",
+                    placeholderName: placeholderDefinition.placeholderName,
+                });
+                placeholderValues[placeholderDefinition.placeholderName] = placeholderDefinition.placeholderName === "ticket" ? this.NORMALIZE_TICKET_ID_USE_CASE.execute(inputValue) : inputValue;
             }
+            const fullBranchName = this.BUILD_BRANCH_NAME_USE_CASE.execute({
+                branchPattern,
+                placeholderValues,
+            });
+            // Re-validate the final assembled branch name with full lint rules before creation.
+            this.LINT_BRANCH_NAME_USE_CASE.execute(fullBranchName, config);
             console.error(`\n⌛️ Creating branch: ${fullBranchName}`);
             // Create the branch
             await this.CREATE_BRANCH_USE_CASE.execute(fullBranchName);
@@ -791,22 +960,22 @@ class LintController {
             this.LINT_BRANCH_NAME_USE_CASE.execute(branchName, config);
         }
         catch (error) {
-            await this.handleError(error);
+            await this.handleError(error, appName);
         }
     }
     /**
      * Handle errors that occur during execution
      * @param error The error that occurred
+     * @param appName The application name
      */
-    async handleError(error) {
+    async handleError(error, appName) {
         if (!(error instanceof Error)) {
             console.error(this.ERROR_FORMATTER.format("[LintBranchName] Unhandled error occurred"));
             throw new Error("Unknown error occurred");
         }
         if (error instanceof LintError) {
             try {
-                // Get the configuration using the service instead of hardcoded values
-                const config = await this.GET_BRANCH_CONFIG_USE_CASE.execute("git-branch-lint");
+                const config = await this.GET_BRANCH_CONFIG_USE_CASE.execute(appName);
                 console.error(this.ERROR_FORMATTER.format(error.message));
                 console.error(this.HINT_FORMATTER.format(error, config));
                 // Since this is a CLI tool, it's appropriate to exit the process on validation errors
@@ -852,10 +1021,15 @@ const main = async () => {
     if (shouldRunBranch) {
         // Application layer - branch creation use cases
         const checkWorkingDirectoryUseCase = new CheckWorkingDirectoryUseCase(branchRepository);
+        const buildBranchNameUseCase = new BuildBranchNameUseCase();
         const createBranchUseCase = new CreateBranchUseCase(branchRepository);
+        const getBranchPatternUseCase = new GetBranchPatternUseCase();
+        const getBranchPlaceholderDefinitionsUseCase = new GetBranchPlaceholderDefinitionsUseCase();
+        const lintBranchNameUseCase = new LintBranchNameUseCase();
+        const normalizeTicketIdUseCase = new NormalizeTicketIdUseCase();
         const pushBranchUseCase = new PushBranchUseCase(branchRepository);
         // Presentation layer
-        const createBranchController = new CreateBranchController(checkWorkingDirectoryUseCase, createBranchUseCase, getBranchConfigUseCase, pushBranchUseCase);
+        const createBranchController = new CreateBranchController(buildBranchNameUseCase, checkWorkingDirectoryUseCase, createBranchUseCase, getBranchPatternUseCase, getBranchPlaceholderDefinitionsUseCase, getBranchConfigUseCase, lintBranchNameUseCase, normalizeTicketIdUseCase, pushBranchUseCase);
         await createBranchController.execute(APP_NAME);
     }
     else {