format-commit 1.0.0 → 1.1.0

package/lib/commit.js

@@ -15,90 +15,6 @@ const options = JSON.parse(
   readFileSync(join(__dirname, 'options.json'), 'utf-8')
 );
 
-
-/** Parse and validate commit title format, auto-correct case */
-const parseAndNormalizeCommitTitle = (title, config) => {
-  let type, scope, message, detectedFormatGroup;
-
-  // Try different format patterns
-  const format7_8 = /^([^(]+)\(([^)]+)\):\s*(.+)$/; // type(scope): message
-  const format5_6 = /^([^(]+)\(([^)]+)\)\s+(.+)$/; // type(scope) message
-  const format3_4 = /^([^:]+):\s*(.+)$/; // type: message
-  const format1_2 = /^\(([^)]+)\)\s+(.+)$/; // (type) message
-
-  let match;
-
-  if ((match = title.match(format7_8))) {
-    [, type, scope, message] = match;
-    detectedFormatGroup = 'type(scope):';
-  } else if ((match = title.match(format5_6))) {
-    [, type, scope, message] = match;
-    detectedFormatGroup = 'type(scope)';
-  } else if ((match = title.match(format3_4))) {
-    [, type, message] = match;
-    detectedFormatGroup = 'type:';
-  } else if ((match = title.match(format1_2))) {
-    [, type, message] = match;
-    detectedFormatGroup = '(type)';
-  } else {
-    return { error: 'Invalid commit format. Expected format with type prefix.' };
-  }
-
-  // Verify format matches config
-  let expectedFormatGroup;
-  if (config.format >= 7) {
-    expectedFormatGroup = 'type(scope):';
-  } else if (config.format >= 5) {
-    expectedFormatGroup = 'type(scope)';
-  } else if (config.format >= 3) {
-    expectedFormatGroup = 'type:';
-  } else {
-    expectedFormatGroup = '(type)';
-  }
-
-  if (detectedFormatGroup !== expectedFormatGroup) {
-    const exampleTitle = utils.formatCommitTitle(
-      config.types[0].value,
-      'name',
-      config.format,
-      config.scopes?.[0]?.value
-    );
-    return { error: `Wrong format. Expected: "${exampleTitle}"` };
-  }
-
-  type = type.trim();
-  message = message.trim();
-  if (scope) {
-    scope = scope.trim();
-  }
-
-  // Validate type exists (case-insensitive)
-  const validType = config.types.find(t => t.value.toLowerCase() === type.toLowerCase());
-  if (!validType) {
-    const validTypes = config.types.map(t => t.value).join(', ');
-    return { error: `Invalid type "${type}". Valid types: ${validTypes}` };
-  }
-
-  // Validate scope if present (case-insensitive)
-  let validScope = scope;
-  if (scope) {
-    if (!config.scopes || config.scopes.length === 0) {
-      return { error: 'Scope not allowed in current format configuration' };
-    }
-    const foundScope = config.scopes.find(s => s.value.toLowerCase() === scope.toLowerCase());
-    if (!foundScope) {
-      const validScopes = config.scopes.map(s => s.value).join(', ');
-      return { error: `Invalid scope "${scope}". Valid scopes: ${validScopes}` };
-    }
-    validScope = foundScope.value;
-  }
-
-  // Re-format with correct case
-  const normalized = utils.formatCommitTitle(validType.value, message, config.format, validScope);
-
-  return { normalized };
-};
-
 /** Prompt with pre-filled text (editable) using readline */
 const promptWithPrefill = (message, prefill, validate) => {
   return new Promise((resolve, reject) => {
@@ -108,7 +24,7 @@ const promptWithPrefill = (message, prefill, validate) => {
         output: process.stdout
       });
 
-      const questionText = `${kleur.bold(message)}\n› `;
+      const questionText = `${kleur.bold(message)}\n> `;
 
       // Handle Ctrl+C to cancel
       rl.on('SIGINT', () => {
@@ -186,19 +102,23 @@ const finalizeCommit = async (title, description, commitData, currentBranch, tes
 };
 
 
-export default async function commit(config, testMode) {
+export default async function commit(config, testMode, debugMode) {
   if (!config) {
     return;
   }
   utils.log('new commit');
 
-  if (!testMode && !utils.hasStagedChanges()) {
+  if (!utils.hasStagedChanges()) {
     utils.log('No staged changes found - stage your changes with git add', 'error');
     return;
   }
 
   if (testMode) {
-    utils.log('test mode enabled - commit will not be performed', 'warning');
+    utils.log('test mode enabled (commit will not be performed)', 'warning');
+  }
+
+  if (debugMode) {
+    utils.log('debug mode enabled (additional visible logs)', 'debug');
   }
 
   // Get current git branch for version change option "only on release branch"
@@ -212,22 +132,71 @@ export default async function commit(config, testMode) {
     return;
   }
 
+  if (config.format === 'custom') {
+    const formatValid = utils.validateCustomFormatPattern(config.customFormat);
+    if (formatValid !== true) {
+      utils.log(`Invalid custom format - ${formatValid}`, 'error');
+      return;
+    }
+  }
+
+  const formatNeedsScope = config.format === 'custom'
+    ? utils.customFormatHasScope(config.customFormat)
+    : config.format >= 5;
+
   const noScope = !config.scopes || (config.scopes && config.scopes.length === 0);
-  if (config.format >= 5 && noScope) {
+  if (formatNeedsScope && noScope) {
     utils.log('no scopes defined - update config or format option', 'error');
     return;
   }
 
+  // Warn if using default example scope and skip AI suggestions
+  const hasDefaultScope = config.scopes && config.scopes.length === 1 && config.scopes[0].value === 'example';
+  if (hasDefaultScope) {
+    utils.log('You are using the default scope "example" - customize your scopes in commit-config.json or run `format-commit --config`', 'warning');
+    utils.log('AI suggestions skipped - configure your scopes', 'warning');
+  }
+
+  // Collect custom field values early (needed before AI and classic flows)
+  let cancelled = false;
+  let customFieldValues = {};
+  if (config.format === 'custom') {
+    const fields = utils.getCustomFields(config.customFormat);
+    for (const label of fields) {
+      const resp = await prompts({
+        type: 'text',
+        name: 'value',
+        message: `${label}?`,
+        validate: v => (!v || !v.trim()) ? `${label} cannot be empty` : true,
+      }, {
+        onCancel: () => {
+          cancelled = true;
+          return false;
+        },
+      });
+      if (cancelled) {
+        utils.log('commit cancelled', 'error');
+        return;
+      }
+      customFieldValues[label] = resp.value;
+    }
+  }
+
   let commitTitle = null;
   let useAISuggestion = false;
 
-  // Try to generate AI suggestions if enabled
-  if (config.ai?.enabled) {
+  if (config.ai?.enabled && !hasDefaultScope) {
     utils.log('generating suggestions...');
     const aiService = await import('./ai-service.js');
-    const suggestions = await aiService.generateCommitSuggestions(config, testMode);
+    let suggestions = [];
+
+    try {
+      suggestions = await aiService.generateCommitSuggestions(config, debugMode, customFieldValues);
+    } catch (err) {
+      utils.log(`AI suggestions failed (${err.message})`, 'warning');
+    }
 
-    if (suggestions && suggestions.length === 4) {
+    if (suggestions?.length) {
       let aiCancelled = false;
       const aiChoice = await prompts({
         type: 'select',
@@ -260,7 +229,7 @@ export default async function commit(config, testMode) {
               }
 
               // Parse and validate format, type, and scope
-              const result = parseAndNormalizeCommitTitle(val, config);
+              const result = utils.parseAndNormalizeCommitTitle(val, config, customFieldValues);
               if (result.error) {
                 return result.error;
               }
@@ -276,7 +245,7 @@ export default async function commit(config, testMode) {
           );
 
           // Normalize the final title (correct case)
-          const result = parseAndNormalizeCommitTitle(rawTitle, config);
+          const result = utils.parseAndNormalizeCommitTitle(rawTitle, config, customFieldValues);
           commitTitle = result.normalized;
           useAISuggestion = true;
         } catch (err) {
@@ -286,13 +255,9 @@ export default async function commit(config, testMode) {
           return;
         }
       }
-    } else {
-      utils.log('AI suggestions failed, using manual input', 'warning');
     }
   }
 
-  let cancelled = false;
-
   // If AI suggestion was accepted, only ask for description, version, and push
   if (useAISuggestion) {
     const commit = await prompts([
@@ -323,7 +288,7 @@ export default async function commit(config, testMode) {
         validate: val => utils.validVersion(val),
       },
       {
-        type: 'confirm',
+        type: testMode ? null : 'confirm',
         name: 'pushAfterCommit',
         message: 'Push changes?',
         initial: false,
@@ -344,7 +309,7 @@ export default async function commit(config, testMode) {
     return;
   }
 
-  // Classic flow: ask for type and scope first
+  // Classic flow: ask for type and scope
   const typeScope = await prompts([
     {
       type: 'select',
@@ -353,7 +318,7 @@ export default async function commit(config, testMode) {
       choices: config.types,
     },
     {
-      type: config.format >= 5 ? 'select' : null,
+      type: formatNeedsScope ? 'select' : null,
       name: 'scope',
       message: 'Scope',
       choices: config.scopes,
@@ -370,7 +335,7 @@ export default async function commit(config, testMode) {
     return;
   }
 
-  // Ask for title with full formatted length validation, then description, version and push
+  // Ask for title with full formatted length validation, then description, and options
   const commit = await prompts([
     {
       type: 'text',
@@ -380,7 +345,10 @@ export default async function commit(config, testMode) {
         if (!val || val.trim().length === 0) {
           return 'Commit title cannot be empty';
         }
-        const fullTitle = utils.formatCommitTitle(typeScope.type, val, config.format, typeScope.scope);
+        const fullTitle = utils.formatCommitTitle(
+          typeScope.type, val, config.format, typeScope.scope,
+          config.customFormat, customFieldValues
+        );
         return utils.validCommitTitle(fullTitle, config.minLength, config.maxLength);
       },
     },
@@ -429,12 +397,13 @@ export default async function commit(config, testMode) {
     return;
   }
 
-  // Format changes message and commit it
   commitTitle = utils.formatCommitTitle(
     typeScope.type,
     commit.title,
     config.format,
-    typeScope.scope
+    typeScope.scope,
+    config.customFormat,
+    customFieldValues
   );
 
   await finalizeCommit(commitTitle, commit.description, commit, currentBranch, testMode);

package/lib/create-branch.js

@@ -23,14 +23,36 @@ export default async function createBranch(config, testMode) {
     return;
   }
 
+  const isCustom = config.branchFormat === 'custom';
+  const customHasScope = isCustom && config.customBranchFormat && utils.customBranchFormatHasScope(config.customBranchFormat);
+  const needsScope = config.branchFormat === 2 || customHasScope;
+
   const noScope = !config.scopes || (config.scopes && config.scopes.length === 0);
-  if (config.branchFormat === 2 && noScope) {
+  if (needsScope && noScope) {
     utils.log('no scopes defined - update config or branch format option', 'error');
     return;
   }
 
+  if (isCustom) {
+    const formatValid = utils.validateCustomBranchFormatPattern(config.customBranchFormat);
+    if (formatValid !== true) {
+      utils.log(`Invalid custom branch format - ${formatValid}`, 'error');
+      return;
+    }
+  }
+
+  // Collect custom fields if custom format
+  const customFields = isCustom ? utils.getCustomBranchFields(config.customBranchFormat) : [];
+  const customFieldPrompts = customFields.map(field => ({
+    type: 'text',
+    name: `custom_${field}`,
+    message: `${field}?`,
+    validate: val => utils.validBranchCustomField(val, field),
+  }));
+
   let cancelled = false;
   const branch = await prompts([
+    ...customFieldPrompts,
     {
       type: 'select',
       name: 'type',
@@ -38,7 +60,7 @@ export default async function createBranch(config, testMode) {
       choices: config.types,
     },
     {
-      type: config.branchFormat === 2 ? 'select' : null,
+      type: needsScope ? 'select' : null,
       name: 'scope',
       message: 'Scope',
       choices: config.scopes,
@@ -50,7 +72,7 @@ export default async function createBranch(config, testMode) {
       validate: val => utils.validBranchDescription(val, config.maxLength),
     },
     {
-      type: 'confirm',
+      type: testMode ? null : 'confirm',
       name: 'checkoutAfterCreate',
       message: 'Switch to the new branch after creation?',
       initial: true,
@@ -67,17 +89,25 @@ export default async function createBranch(config, testMode) {
     return;
   }
 
+  // Build custom field values from prompt answers
+  const customFieldValues = {};
+  for (const field of customFields) {
+    customFieldValues[field] = branch[`custom_${field}`];
+  }
+
   // Format branch name and create it
   utils.log('create branch...');
   const branchName = utils.formatBranchName(
     branch.type,
     branch.description,
     config.branchFormat,
-    branch.scope
+    branch.scope,
+    config.customBranchFormat,
+    customFieldValues
   );
 
   if (testMode) {
-    utils.log(`Branch name: ${branchName}`, 'warning');
+    utils.log(`branch name: ${branchName}`, 'warning');
     return;
   }
 

package/lib/index.js

@@ -26,12 +26,13 @@ program
   .version('0.3.1')
   .option('-b, --branch', 'create a new branch with standardized naming')
   .option('-c, --config', 'generate a configuration file on your project for format-commit')
-  .option('-t, --test', 'start without finalize commit (for tests)');
+  .option('-t, --test', 'start without finalize commit (for tests)')
+  .option('-d, --debug', 'display additional logs');
 
 try {
   program.parse(process.argv);
-} catch (error) {
-  console.error('Error parsing arguments:', error.message);
+} catch (err) {
+  console.error('Error parsing arguments:', err.message);
   process.exit(1);
 }
 
@@ -49,7 +50,7 @@ try {
       utils.log('no configuration found', 'warning');
       const setupResult = await setup(true);
       if (setupResult && setupResult.commitAfter) {
-        commit(setupResult.config, opts.test);
+        commit(setupResult.config, opts.test, opts.debug);
       }
     } else {
       if (opts.branch) {
@@ -57,7 +58,7 @@ try {
         createBranch(JSON.parse(data), opts.test);
         return;
       }
-      commit(JSON.parse(data), opts.test);
+      commit(JSON.parse(data), opts.test, opts.debug);
     }
   });
 })();

package/lib/options.json

@@ -1,14 +1,14 @@
 {
   "configFile": "commit-config",
   "commitFormats": [
-    { "value": 1, "title": "(type) Name" },
-    { "value": 2, "title": "(type) name" },
-    { "value": 3, "title": "type: Name"  },
-    { "value": 4, "title": "type: name" },
-    { "value": 5, "title": "type(scope) Name" },
-    { "value": 6, "title": "type(scope) name" },
-    { "value": 7, "title": "type(scope): Name" },
-    { "value": 8, "title": "type(scope): name" }
+    { "value": 1, "title": "(type) Description" },
+    { "value": 2, "title": "(type) description" },
+    { "value": 3, "title": "type: Description"  },
+    { "value": 4, "title": "type: description" },
+    { "value": 5, "title": "type(scope) Description" },
+    { "value": 6, "title": "type(scope) description" },
+    { "value": 7, "title": "type(scope): Description" },
+    { "value": 8, "title": "type(scope): description" }
   ],
   "branchFormats": [
     { "value": 1, "title": "type/description" },

package/lib/setup.js

@@ -1,4 +1,5 @@
 import prompts from 'prompts';
+import kleur from 'kleur';
 import fs, { readFileSync } from 'fs';
 import * as utils from './utils.js';
 import * as envUtils from './env-utils.js';
@@ -29,13 +30,31 @@ export default async function setup(askForCommitAfter) {
       type: 'select',
       name: 'format',
       message: 'Commit messages nomenclature',
-      choices: options.commitFormats,
+      choices: [
+        ...options.commitFormats,
+        { value: 'custom', title: kleur.gray('Custom - define your own pattern') },
+      ],
+    },
+    {
+      type: prev => prev === 'custom' ? 'text' : null,
+      name: 'customFormat',
+      message: 'Custom format pattern (e.g. `{Issue ID} - type - scope - Description`)',
+      validate: val => utils.validateCustomFormatPattern(val),
     },
     {
       type: 'select',
       name: 'branchFormat',
       message: 'Branch names nomenclature',
-      choices: options.branchFormats,
+      choices: [
+        ...options.branchFormats,
+        { value: 'custom', title: kleur.gray('Custom - define your own pattern') },
+      ],
+    },
+    {
+      type: prev => prev === 'custom' ? 'text' : null,
+      name: 'customBranchFormat',
+      message: 'Custom branch format pattern (e.g. `{Issue ID}-type/description`)',
+      validate: val => utils.validateCustomBranchFormatPattern(val),
     },
     {
       type: 'number',
@@ -196,13 +215,20 @@ export default async function setup(askForCommitAfter) {
   }
 
   // Parse prompt data and write config file
+  const needsScope = (
+    (configChoices.format !== 'custom' && configChoices.format >= 5) ||
+    (configChoices.format === 'custom' && utils.customFormatHasScope(configChoices.customFormat)) ||
+    configChoices.branchFormat === 2 ||
+    (configChoices.branchFormat === 'custom' && utils.customBranchFormatHasScope(configChoices.customBranchFormat))
+  );
+
   const config = {
     format: configChoices.format,
+    customFormat: configChoices.format === 'custom' ? configChoices.customFormat : undefined,
     branchFormat: configChoices.branchFormat,
+    customBranchFormat: configChoices.branchFormat === 'custom' ? configChoices.customBranchFormat : undefined,
     types: defaultConfig.types,
-    scopes: (configChoices.format >= 5 || configChoices.branchFormat === 2)
-      ? defaultConfig.scopes
-      : undefined,
+    scopes: needsScope ? defaultConfig.scopes : undefined,
     minLength: configChoices.minLength,
     maxLength: configChoices.maxLength,
     changeVersion: configChoices.changeVersion,
@@ -255,8 +281,9 @@ export default async function setup(askForCommitAfter) {
   try {
     fs.writeFileSync(`./${options.configFile}.json`, parsedConfig);
     utils.log('config file successfully created', 'success');
+    utils.log(`Customize default types and scopes in ${options.configFile}.json`);
   } catch (err) {
-    utils.log(`unable to save config file: ${err}`, 'error');
+    utils.log(`Unable to save config file: ${err.message}`, 'error');
     return;
   }