format-commit 0.4.0 → 1.0.0

package/lib/commit.js

@@ -1,25 +1,210 @@
-'use strict';
+import prompts from 'prompts';
+import kleur from 'kleur';
+import readline from 'readline';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import * as utils from './utils.js';
 
-const prompts = require('prompts');
-const utils = require('./utils');
-const options = require('./options.json');
 
+const { gray } = kleur;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
-module.exports = async (config, testMode) => {
+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) => {
+    const askQuestion = (text) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      const questionText = `${kleur.bold(message)}\n› `;
+
+      // Handle Ctrl+C to cancel
+      rl.on('SIGINT', () => {
+        rl.close();
+        console.log('');
+        reject(new Error('cancelled'));
+      });
+
+      rl.question(questionText, (answer) => {
+        rl.close();
+
+        const validation = validate ? validate(answer) : true;
+        if (validation !== true) {
+          utils.log(validation, 'error');
+          // Ask again with current answer as prefill
+          askQuestion(answer);
+          return;
+        }
+
+        resolve(answer);
+      });
+
+      rl.write(text);
+    };
+
+    askQuestion(prefill);
+  });
+};
+
+
+/** Execute commit, handle version bump, push and show status */
+const finalizeCommit = async (title, description, commitData, currentBranch, testMode) => {
+  utils.log('commit changes...');
+
+  if (testMode) {
+    utils.log(title, 'warning');
+    return;
+  }
+
+  const commitRes = utils.handleCmdExec(`git commit -m "${title}" -m "${description}"`);
+  if (!commitRes) {
+    return;
+  }
+  utils.log('commit successfully completed', 'success');
+  console.log(commitRes);
+
+  let newVersion = null;
+  if (commitData.version === 'prerelease') {
+    const preRelease = await prompts([
+      {
+        type: 'text',
+        name: 'tag',
+        message: 'Pre-release tag?',
+      },
+    ]);
+    utils.log('update version...');
+    newVersion = utils.handleCmdExec(`npm version ${commitData.version} --preid=${preRelease.tag}`);
+  } else if (commitData.version) {
+    utils.log('update version...');
+    const version = commitData.customVersion ? commitData.customVersion : commitData.version;
+    newVersion = utils.handleCmdExec(`npm version ${version} --allow-same-version`);
+  }
+
+  if (newVersion) {
+    utils.log(`package updated to ${newVersion}`);
+  }
+
+  if (commitData.pushAfterCommit) {
+    utils.log('push changes...');
+    const gitPush = utils.handleCmdExec(`git push -u origin ${currentBranch}`);
+    console.log(gitPush);
+  }
+  const gitStatus = utils.handleCmdExec('git status');
+  console.log(gitStatus);
+};
+
+
+export default async function commit(config, testMode) {
   if (!config) {
     return;
   }
   utils.log('new commit');
 
+  if (!testMode && !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');
   }
 
-  /**
-   * Get current git branch for version change option "only on release branch"
-  */
+  // Get current git branch for version change option "only on release branch"
   const currentBranch = utils.getCurrentBranch();
   const askForVersion = utils.askForVersion(config, currentBranch);
+  const ignoreVersion = config.changeVersion === 'ignore';
 
   const noType = !config.types || (config.types && config.types.length === 0);
   if (noType) {
@@ -33,8 +218,134 @@ module.exports = async (config, testMode) => {
     return;
   }
 
+  let commitTitle = null;
+  let useAISuggestion = false;
+
+  // Try to generate AI suggestions if enabled
+  if (config.ai?.enabled) {
+    utils.log('generating suggestions...');
+    const aiService = await import('./ai-service.js');
+    const suggestions = await aiService.generateCommitSuggestions(config, testMode);
+
+    if (suggestions && suggestions.length === 4) {
+      let aiCancelled = false;
+      const aiChoice = await prompts({
+        type: 'select',
+        name: 'selectedTitle',
+        message: 'Start with a suggested title?',
+        choices: [
+          ...suggestions.map(s => ({ title: s, value: s })),
+          { title: gray('Custom (enter manually)'), value: '__custom__' },
+        ],
+      }, {
+        onCancel: () => {
+          aiCancelled = true;
+          return false;
+        },
+      });
+
+      if (aiCancelled) {
+        utils.log('commit cancelled', 'error');
+        return;
+      }
+
+      if (aiChoice.selectedTitle && aiChoice.selectedTitle !== '__custom__') {
+        try {
+          const rawTitle = await promptWithPrefill(
+            'Edit commit title or continue:',
+            aiChoice.selectedTitle,
+            val => {
+              if (!val || val.trim().length === 0) {
+                return 'Commit title cannot be empty';
+              }
+
+              // Parse and validate format, type, and scope
+              const result = parseAndNormalizeCommitTitle(val, config);
+              if (result.error) {
+                return result.error;
+              }
+
+              // Validate length of normalized title
+              const lengthCheck = utils.validCommitTitle(result.normalized, config.minLength, config.maxLength);
+              if (lengthCheck !== true) {
+                return lengthCheck;
+              }
+
+              return true;
+            }
+          );
+
+          // Normalize the final title (correct case)
+          const result = parseAndNormalizeCommitTitle(rawTitle, config);
+          commitTitle = result.normalized;
+          useAISuggestion = true;
+        } catch (err) {
+          if (err.message === 'cancelled') {
+            utils.log('commit cancelled', 'error');
+          }
+          return;
+        }
+      }
+    } else {
+      utils.log('AI suggestions failed, using manual input', 'warning');
+    }
+  }
+
   let cancelled = false;
-  const commit = await prompts([
+
+  // If AI suggestion was accepted, only ask for description, version, and push
+  if (useAISuggestion) {
+    const commit = await prompts([
+      {
+        type: 'text',
+        name: 'description',
+        message: 'Commit description?',
+        validate: val => val.length > 255 ? 'Commit description too long' : true,
+      },
+      {
+        type: ignoreVersion ? null : (askForVersion ? null : 'confirm'),
+        name: 'changeVersion',
+        message: 'Change package version?',
+        initial: false,
+      },
+      {
+        type: prev => ignoreVersion ? null : (askForVersion | prev ? 'select' : null),
+        name: 'version',
+        message: 'Type of version change',
+        choices: config.showAllVersionTypes
+          ? [...options.versionTypes, ...options.allVersionTypes]
+          : options.versionTypes,
+      },
+      {
+        type: prev => prev === 'custom' ? 'text' : null,
+        name: 'customVersion',
+        message: 'Version?',
+        validate: val => utils.validVersion(val),
+      },
+      {
+        type: 'confirm',
+        name: 'pushAfterCommit',
+        message: 'Push changes?',
+        initial: false,
+      },
+    ], {
+      onCancel: () => {
+        cancelled = true;
+        return false;
+      },
+    });
+
+    if (cancelled) {
+      utils.log('commit cancelled', 'error');
+      return;
+    }
+
+    await finalizeCommit(commitTitle, commit.description, commit, currentBranch, testMode);
+    return;
+  }
+
+  // Classic flow: ask for type and scope first
+  const typeScope = await prompts([
     {
       type: 'select',
       name: 'type',
@@ -47,11 +358,31 @@ module.exports = async (config, testMode) => {
       message: 'Scope',
       choices: config.scopes,
     },
+  ], {
+    onCancel: () => {
+      cancelled = true;
+      return false;
+    },
+  });
+
+  if (cancelled) {
+    utils.log('commit cancelled', 'error');
+    return;
+  }
+
+  // Ask for title with full formatted length validation, then description, version and push
+  const commit = await prompts([
     {
       type: 'text',
       name: 'title',
       message: 'Commit title?',
-      validate: val => utils.validCommitTitle(val, config.minLength, config.maxLength),
+      validate: val => {
+        if (!val || val.trim().length === 0) {
+          return 'Commit title cannot be empty';
+        }
+        const fullTitle = utils.formatCommitTitle(typeScope.type, val, config.format, typeScope.scope);
+        return utils.validCommitTitle(fullTitle, config.minLength, config.maxLength);
+      },
     },
     {
       type: 'text',
@@ -60,18 +391,16 @@ module.exports = async (config, testMode) => {
       validate: val => val.length > 255 ? 'Commit description too long' : true,
     },
     {
-      type: askForVersion ? null : 'confirm',
+      type: ignoreVersion ? null : (askForVersion ? null : 'confirm'),
       name: 'changeVersion',
       message: 'Change package version?',
       initial: false,
     },
     {
-      type: prev => askForVersion | prev ? 'select' : null,
+      type: prev => ignoreVersion ? null : (askForVersion | prev ? 'select' : null),
       name: 'version',
       message: 'Type of version change',
-      /**
-       * Display only some npm version options or all depending on config
-       */
+      // Display only some npm version options or all depending on config
       choices: config.showAllVersionTypes
         ? [...options.versionTypes, ...options.allVersionTypes]
         : options.versionTypes,
@@ -95,73 +424,18 @@ module.exports = async (config, testMode) => {
     },
   });
 
-  /**
-   * Handle prompt cancellation and stop commit execution
-   */
   if (cancelled) {
     utils.log('commit cancelled', 'error');
     return;
   }
 
-  /**
-   * Format changes message and commit it
-   */
-  utils.log('commit changes...');
-  const commitTitle = utils.formatCommitTitle(
-    commit.type,
+  // Format changes message and commit it
+  commitTitle = utils.formatCommitTitle(
+    typeScope.type,
     commit.title,
     config.format,
-    commit.scope
+    typeScope.scope
   );
 
-  if (testMode) {
-    utils.log(commitTitle, 'warning');
-    return;
-  }
-
-  const commitRes = utils.handleCmdExec(`git commit -m "${commitTitle}" -m "${commit.description}"`);
-  if (!commitRes) {
-    return;
-  }
-  utils.log('commit successfully completed', 'success');
-  console.log(commitRes);
-
-  let newVersion = null;
-  if (commit.version === 'prerelease') {
-    /**
-     * Ask tag if new version is a prerelease and update it
-     */
-    const preRelease = await prompts([
-      {
-        type: 'text',
-        name: 'tag',
-        message: 'Pre-release tag?',
-      },
-    ]);
-    utils.log('update version...');
-    newVersion = utils.handleCmdExec(`npm version ${commit.version} --preid=${preRelease.tag}`);
-
-  } else if (commit.version) {
-    /**
-     * Ask version if custom option selected and update it
-     */
-    utils.log('update version...');
-    const version = commit.customVersion ? commit.customVersion : commit.version;
-    newVersion = utils.handleCmdExec(`npm version ${version} --allow-same-version`);
-  }
-
-  if (newVersion) {
-    utils.log(`package updated to ${newVersion}`);
-  }
-
-  /**
-   * Push commit if option selection
-   */
-  if (commit.pushAfterCommit) {
-    utils.log('push changes...');
-    const gitPush = utils.handleCmdExec(`git push -u origin ${currentBranch}`);
-    console.log(gitPush);
-  }
-  const gitStatus = utils.handleCmdExec('git status');
-  console.log(gitStatus);
-};
+  await finalizeCommit(commitTitle, commit.description, commit, currentBranch, testMode);
+}

package/lib/create-branch.js

@@ -1,10 +1,8 @@
-'use strict';
+import prompts from 'prompts';
+import * as utils from './utils.js';
 
-const prompts = require('prompts');
-const utils = require('./utils');
 
-
-module.exports = async (config, testMode) => {
+export default async function createBranch(config, testMode) {
   if (!config) {
     return;
   }
@@ -14,9 +12,6 @@ module.exports = async (config, testMode) => {
     utils.log('test mode enabled - branch will not be created', 'warning');
   }
 
-  /**
-   * Check if branchFormat is configured
-   */
   if (!config.branchFormat) {
     utils.log('no branch format defined - please update config', 'error');
     return;
@@ -67,17 +62,12 @@ module.exports = async (config, testMode) => {
     },
   });
 
-  /**
-   * Handle prompt cancellation and stop branch creation
-   */
   if (cancelled) {
     utils.log('branch creation cancelled', 'error');
     return;
   }
 
-  /**
-   * Format branch name and create it
-   */
+  // Format branch name and create it
   utils.log('create branch...');
   const branchName = utils.formatBranchName(
     branch.type,
@@ -91,18 +81,12 @@ module.exports = async (config, testMode) => {
     return;
   }
 
-  /**
-   * Check if branch already exists
-   */
   const branchExists = utils.checkBranchExists(branchName);
   if (branchExists) {
     utils.log(`branch "${branchName}" already exists`, 'error');
     return;
   }
 
-  /**
-   * Create the branch
-   */
   const createCommand = branch.checkoutAfterCreate
     ? `git checkout -b ${branchName}`
     : `git branch ${branchName}`;
@@ -119,9 +103,6 @@ module.exports = async (config, testMode) => {
   utils.log(successMessage, 'success');
   console.log(createRes);
 
-  /**
-   * Show current git status
-   */
   const gitStatus = utils.handleCmdExec('git status');
   console.log(gitStatus);
-};
+}

package/lib/default-config.json

@@ -3,7 +3,7 @@
   "branchFormat": 1,
   "minLength": 8,
   "maxLength": 80,
-  "changeVersion": "never",
+  "changeVersion": "ignore",
   "releaseBranch": "main",
   "showAllVersionTypes": false,
   "types": [
@@ -16,5 +16,10 @@
   ],
   "scopes": [
     { "value": "example", "description": "Your scope's description" }
-  ]
+  ],
+  "ai": {
+    "enabled": false,
+    "envPath": ".env",
+    "largeDiffTokenThreshold": 20000
+  }
 }

package/lib/env-utils.js

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+
+
+/** Check if a file path is in .gitignore */
+const isInGitignore = (filePath) => {
+  try {
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+      return false;
+    }
+    const gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
+    const lines = gitignoreContent.split('\n').map(l => l.trim());
+
+    const normalizedPath = filePath.startsWith('./') ? filePath.slice(2) : filePath;
+
+    return lines.some(line => {
+      if (!line || line.startsWith('#')) {return false;}
+      return line === normalizedPath || line === `/${normalizedPath}`;
+    });
+  } catch {
+    return false;
+  }
+};
+
+/** Add a file to .gitignore */
+const addToGitignore = (filePath) => {
+  try {
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    const normalizedPath = filePath.startsWith('./') ? filePath.slice(2) : filePath;
+
+    let content = '';
+    if (fs.existsSync(gitignorePath)) {
+      content = fs.readFileSync(gitignorePath, 'utf-8');
+      if (!content.endsWith('\n')) {
+        content += '\n';
+      }
+    }
+
+    content += `${normalizedPath}\n`;
+    fs.writeFileSync(gitignorePath, content);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/** Check if a key exists in .env file */
+const keyExistsInEnv = (envPath, keyName) => {
+  try {
+    if (!fs.existsSync(envPath)) {
+      return false;
+    }
+    const content = fs.readFileSync(envPath, 'utf-8');
+    const regex = new RegExp(`^${keyName}=`, 'm');
+    return regex.test(content);
+  } catch {
+    return false;
+  }
+};
+
+/** Add or update a key in .env file */
+const setEnvKey = (envPath, keyName, value) => {
+  try {
+    let content = '';
+
+    if (fs.existsSync(envPath)) {
+      content = fs.readFileSync(envPath, 'utf-8');
+      const regex = new RegExp(`^${keyName}=.*$`, 'm');
+
+      if (regex.test(content)) {
+        content = content.replace(regex, `${keyName}=${value}`);
+      } else {
+        if (!content.endsWith('\n')) {content += '\n';}
+        content += `${keyName}=${value}\n`;
+      }
+    } else {
+      content = `${keyName}=${value}\n`;
+    }
+
+    fs.writeFileSync(envPath, content);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/** Read a key from .env file */
+const getEnvKey = (envPath, keyName) => {
+  try {
+    if (!fs.existsSync(envPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(envPath, 'utf-8');
+    const regex = new RegExp(`^${keyName}=(.*)$`, 'm');
+    const match = content.match(regex);
+    return match ? match[1].trim() : null;
+  } catch {
+    return null;
+  }
+};
+
+export {
+  isInGitignore,
+  addToGitignore,
+  keyExistsInEnv,
+  setEnvKey,
+  getEnvKey,
+};