format-commit 0.4.0 → 1.0.1

package/lib/options.json

@@ -15,6 +15,7 @@
     { "value": 2, "title": "type/scope/description" }
   ],
   "versionChangeMode": [
+    { "value": "ignore", "title": "never (ignore)" },
     { "value": "never", "title": "never (always ask)" },
     { "value": "releaseBranch", "title": "only on release branch" },
     { "value": "always" }
@@ -31,5 +32,31 @@
     { "value": "premajor" },
     { "value": "prerelease", "title": "prerelease <tag>" },
     { "value": "from-git" }
+  ],
+  "aiProviders": [
+    {
+      "value": "anthropic",
+      "title": "Anthropic (Claude)",
+      "models": [
+        { "value": "claude-haiku-4-5", "title": "Claude Haiku 4.5 (Fast & Cheap)" },
+        { "value": "claude-sonnet-4-5", "title": "Claude Sonnet 4.5 (Balanced)" }
+      ]
+    },
+    {
+      "value": "openai",
+      "title": "OpenAI (GPT)",
+      "models": [
+        { "value": "gpt-4o-mini", "title": "GPT-4o Mini (Fast & Cheap)" },
+        { "value": "gpt-4o", "title": "GPT-4o (More Capable)" }
+      ]
+    },
+    {
+      "value": "google",
+      "title": "Google (Gemini)",
+      "models": [
+        { "value": "gemini-2.0-flash", "title": "Gemini 2.0 Flash (Fast & Free)" },
+        { "value": "gemini-1.5-pro", "title": "Gemini 1.5 Pro (More Capable)" }
+      ]
+    }
   ]
 }

package/lib/setup.js

@@ -1,18 +1,26 @@
-'use strict';
+import prompts from 'prompts';
+import fs, { readFileSync } from 'fs';
+import * as utils from './utils.js';
+import * as envUtils from './env-utils.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
 
-const prompts = require('prompts');
-const fs = require('fs');
-const utils = require('./utils');
-const defaultConfig = require('./default-config.json');
-const options = require('./options.json');
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
-module.exports = async (askForCommitAfter) => {
+const defaultConfig = JSON.parse(
+  readFileSync(join(__dirname, 'default-config.json'), 'utf-8')
+);
+const options = JSON.parse(
+  readFileSync(join(__dirname, 'options.json'), 'utf-8')
+);
+
+
+export default async function setup(askForCommitAfter) {
   utils.log('create config file');
 
-  /**
-   * Get current git branch to pre-fill release branch option
-  */
+  // Get current git branch to pre-fill release branch option
   const currentBranch = utils.getCurrentBranch();
 
   let cancelled = false;
@@ -61,6 +69,114 @@ module.exports = async (askForCommitAfter) => {
       message: 'Display all npm version types?',
       initial: defaultConfig.showAllVersionTypes,
     },
+    {
+      type: 'confirm',
+      name: 'enableAI',
+      message: 'Enable AI commit title suggestions? (API key required)',
+      initial: false,
+    },
+    {
+      type: prev => prev ? 'select' : null,
+      name: 'aiProvider',
+      message: 'AI provider',
+      choices: options.aiProviders,
+    },
+    {
+      type: prev => prev ? 'select' : null,
+      name: 'aiModel',
+      message: 'AI model',
+      choices: (prev, values) => {
+        const provider = options.aiProviders.find(p => p.value === values.aiProvider);
+        return provider ? provider.models : [];
+      },
+    },
+    {
+      type: (prev, values) => values.enableAI ? 'text' : null,
+      name: 'envPath',
+      message: 'Path to .env file for API key (will be created if doesn\'t exist)',
+      initial: '.env',
+      validate: (val) => {
+        if (!val || val.trim().length === 0) {
+          return 'Please provide a .env file path';
+        }
+
+        const envPath = val.trim();
+        const envExists = fs.existsSync(envPath);
+
+        // If .env exists, check that it is in .gitignore
+        if (envExists && !envUtils.isInGitignore(envPath)) {
+          return `${envPath} must be in .gitignore for security. Please add it first.`;
+        }
+
+        return true;
+      },
+    },
+    {
+      type: (prev, values) => {
+        if (!values.enableAI) { return null; }
+        return fs.existsSync(values.envPath) ? 'text' : null;
+      },
+      name: 'envKeyName',
+      message: 'Name of the API key variable in .env (leave empty to create new)',
+      initial: (prev, values) => `${values.aiProvider.toUpperCase()}_API_KEY`,
+      validate: (val) => {
+        if (!val || val.trim().length === 0) {
+          return 'Please provide a variable name';
+        }
+        return true;
+      },
+    },
+    {
+      type: (prev, values) => {
+        if (!values.enableAI) { return null; }
+
+        const keyName = values.envKeyName || `${values.aiProvider.toUpperCase()}_API_KEY`;
+        const keyExists = envUtils.keyExistsInEnv(values.envPath, keyName);
+
+        if (keyExists) {
+          return 'confirm';
+        }
+
+        return null;
+      },
+      name: 'updateApiKey',
+      message: (prev, values) => {
+        const keyName = values.envKeyName || `${values.aiProvider.toUpperCase()}_API_KEY`;
+        const keyExists = envUtils.keyExistsInEnv(values.envPath, keyName);
+
+        if (keyExists) {
+          return `${keyName} already exists in ${values.envPath}. Update it?`;
+        }
+        const providerNames = { anthropic: 'Anthropic', openai: 'OpenAI', google: 'Google' };
+        return `Enter your ${providerNames[values.aiProvider] || values.aiProvider} API key`;
+      },
+      initial: false,
+    },
+    {
+      type: (prev, values) => {
+        if (!values.enableAI) { return null; }
+
+        const keyName = values.envKeyName || `${values.aiProvider.toUpperCase()}_API_KEY`;
+        const keyExists = envUtils.keyExistsInEnv(values.envPath, keyName);
+
+        if (!keyExists || prev === true) {
+          return 'password';
+        }
+
+        return null;
+      },
+      name: 'apiKey',
+      message: (prev, values) => {
+        const providerNames = { anthropic: 'Anthropic', openai: 'OpenAI', google: 'Google' };
+        return `Enter your ${providerNames[values.aiProvider] || values.aiProvider} API key`;
+      },
+      validate: (val) => {
+        if (!val || val.trim().length < 20) {
+          return 'Please provide a valid API key';
+        }
+        return true;
+      },
+    },
     {
       type: askForCommitAfter ? 'confirm' : null,
       name: 'commitAfter',
@@ -74,17 +190,12 @@ module.exports = async (askForCommitAfter) => {
     },
   });
 
-  /**
-   * Handle prompt cancellation and stop setup execution
-   */
   if (cancelled) {
     utils.log('setup cancelled', 'error');
     return;
   }
 
-  /**
-   * Parse prompt data and write config file
-   */
+  // Parse prompt data and write config file
   const config = {
     format: configChoices.format,
     branchFormat: configChoices.branchFormat,
@@ -98,6 +209,45 @@ module.exports = async (askForCommitAfter) => {
     releaseBranch: configChoices.releaseBranch,
     showAllVersionTypes: configChoices.showAllVersionTypes,
   };
+
+  // Handle AI configuration
+  if (configChoices.enableAI) {
+    const envPath = configChoices.envPath;
+    const keyName = configChoices.envKeyName || `${configChoices.aiProvider.toUpperCase()}_API_KEY`;
+
+    if (configChoices.apiKey) {
+      const saved = envUtils.setEnvKey(envPath, keyName, configChoices.apiKey);
+      if (!saved) {
+        utils.log(`Failed to save API key to ${envPath}`, 'error');
+        return;
+      }
+      utils.log(`API key saved to ${envPath}`, 'success');
+    }
+
+    if (!envUtils.isInGitignore(envPath)) {
+      const added = envUtils.addToGitignore(envPath);
+      if (added) {
+        utils.log(`${envPath} added to .gitignore`, 'success');
+      } else {
+        utils.log(`Failed to add ${envPath} to .gitignore`, 'warning');
+      }
+    }
+
+    config.ai = {
+      enabled: true,
+      provider: configChoices.aiProvider,
+      model: configChoices.aiModel,
+      envPath: envPath,
+      envKeyName: keyName,
+      largeDiffTokenThreshold: defaultConfig.ai.largeDiffTokenThreshold,
+    };
+  } else {
+    config.ai = {
+      enabled: false,
+      largeDiffTokenThreshold: defaultConfig.ai.largeDiffTokenThreshold,
+    };
+  }
+
   const parsedConfig = JSON.stringify(config, null, 2);
 
   utils.log(`save ${options.configFile}.json file...`);
@@ -105,8 +255,9 @@ module.exports = async (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;
   }
 
@@ -114,4 +265,4 @@ module.exports = async (askForCommitAfter) => {
     config,
     commitAfter: configChoices.commitAfter
   };
-};
+}

package/lib/utils.js

@@ -1,8 +1,8 @@
-'use strict';
+import { execSync } from 'child_process';
+import kleur from 'kleur';
 
-const { execSync } = require('child_process');
-const { gray, bold, red, green, yellow } = require('kleur');
 
+const { gray, bold, red, green, yellow } = kleur;
 
 const askForVersion = (config, branch) => {
   if (
@@ -18,11 +18,20 @@ const getCurrentBranch = () => {
   return execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
 };
 
+const hasStagedChanges = () => {
+  try {
+    const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' });
+    return staged.trim().length > 0;
+  } catch {
+    return false;
+  }
+};
+
 const validCommitTitle = (title, lenMin, lenMax) => {
   if (title.length < lenMin) {
-    return 'Commit title too short';
+    return `Commit title too short (current ${title.length} - minimum ${lenMin})`;
   } else if (title.length > lenMax) {
-    return 'Commit title too long';
+    return `Commit title too long (current ${title.length} - maximum ${lenMax})`;
   }
   return true;
 };
@@ -45,24 +54,31 @@ const validVersion = (version) => {
 };
 
 const formatCommitTitle = (type, title, format, scope = '*') => {
+  // Handle empty title
+  if (!title || title.trim().length === 0) {
+    return '';
+  }
+
+  const trimmedTitle = title.trim();
+
   switch (format) {
     case 1:
     default:
-      return `(${type}) ${title[0].toUpperCase()}${title.substr(1).toLowerCase()}`;
+      return `(${type}) ${trimmedTitle[0].toUpperCase()}${trimmedTitle.slice(1).toLowerCase()}`;
     case 2:
-      return `(${type}) ${title.toLowerCase()}`;
+      return `(${type}) ${trimmedTitle.toLowerCase()}`;
     case 3:
-      return `${type}: ${title[0].toUpperCase()}${title.substr(1).toLowerCase()}`;
+      return `${type}: ${trimmedTitle[0].toUpperCase()}${trimmedTitle.slice(1).toLowerCase()}`;
     case 4:
-      return `${type}: ${title.toLowerCase()}`;
+      return `${type}: ${trimmedTitle.toLowerCase()}`;
     case 5:
-      return `${type}(${scope}) ${title[0].toUpperCase()}${title.substr(1).toLowerCase()}`;
+      return `${type}(${scope}) ${trimmedTitle[0].toUpperCase()}${trimmedTitle.slice(1).toLowerCase()}`;
     case 6:
-      return `${type}(${scope}) ${title.toLowerCase()}`;
+      return `${type}(${scope}) ${trimmedTitle.toLowerCase()}`;
     case 7:
-      return `${type}(${scope}): ${title[0].toUpperCase()}${title.substr(1).toLowerCase()}`;
+      return `${type}(${scope}): ${trimmedTitle[0].toUpperCase()}${trimmedTitle.slice(1).toLowerCase()}`;
     case 8:
-      return `${type}(${scope}): ${title.toLowerCase()}`;
+      return `${type}(${scope}): ${trimmedTitle.toLowerCase()}`;
   }
 };
 
@@ -143,10 +159,94 @@ const checkBranchExists = (branchName) => {
   }
 };
 
+/** 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 = 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 = formatCommitTitle(validType.value, message, config.format, validScope);
+
+  return { normalized };
+};
+
 
-module.exports = {
+export {
   askForVersion,
   getCurrentBranch,
+  hasStagedChanges,
   validCommitTitle,
   validCommitTitleSetupLength,
   validBranchDescription,
@@ -154,6 +254,7 @@ module.exports = {
   formatCommitTitle,
   formatBranchName,
   checkBranchExists,
+  parseAndNormalizeCommitTitle,
   handleCmdExec,
   log,
 };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "format-commit",
-  "version": "0.4.0",
-  "description": "Lightweight CLI to standardize commit messages",
-  "license": "ISC",
+  "version": "1.0.1",
+  "description": "Lightweight CLI to standardize commit messages with AI-powered suggestions",
+  "license": "MIT",
   "author": "Thomas BARKATS",
   "keywords": [
     "git",
@@ -16,7 +16,12 @@
     "workflow",
     "tool",
     "javascript",
-    "nodejs"
+    "nodejs",
+    "ai",
+    "gpt",
+    "claude",
+    "openai",
+    "anthropic"
   ],
   "repository": {
     "type": "git",
@@ -27,7 +32,7 @@
     "url": "https://github.com/thomasbarkats/format-commit/issues"
   },
   "main": "./lib/index.js",
-  "type": "commonjs",
+  "type": "module",
   "engines": {
     "node": ">=16.0.0"
   },
@@ -45,7 +50,7 @@
     "format-commit": "./lib/index.js"
   },
   "dependencies": {
-    "commander": "^14.0.0",
+    "commander": "^14.0.3",
     "kleur": "^4.1.5",
     "prompts": "^2.4.2"
   },