opencommit 1.1.15 → 1.1.17

package/README.md

@@ -84,6 +84,32 @@ To remove description:
 oc config set description=false
 ```
 
+### Git flags
+
+The `opencommit` or `oc` commands can be used in place of the `git commit -m "${generatedMessage}"` command. This means that any regular flags that are used with the `git commit` command will also be applied when using `opencommit` or `oc`.
+
+```sh
+oc --no-verify
+```
+
+is translated to :
+
+```sh
+git commit -m "${generatedMessage}" --no-verify
+```
+
+### Ignore files
+You can ignore files from submission to OpenAI by creating a `.opencommitignore` file. For example:
+
+```ignorelang
+path/to/large-asset.zip
+**/*.jpg
+```
+
+This is useful for preventing opencommit from uploading artifacts and large files.
+
+By default, opencommit ignores files matching: `*-lock.*` and `*.lock`
+
 ## Git hook
 
 You can set OpenCommit as Git [`prepare-commit-msg`](https://git-scm.com/docs/githooks#_prepare_commit_msg) hook. Hook integrates with you IDE Source Control and allows you edit the message before commit.

package/out/cli.cjs

@@ -1138,6 +1138,287 @@ var require_merge_stream = __commonJS({
   }
 });
 
+// node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/ignore/index.js"(exports, module2) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => Object.defineProperty(object, key, { value });
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        /\\?\s+$/,
+        (match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
+      ],
+      [
+        /\\\s/g,
+        () => SPACE
+      ],
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      [
+        /^\//,
+        () => "^"
+      ],
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        /^\^*\\\*\\\*\\\//,
+        () => "^(?:.*\\/)?"
+      ],
+      [
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      [
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        (_6, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      [
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        (_6, p1, p22) => {
+          const unescaped = p22.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      [
+        /(?:[^*])$/,
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ],
+      [
+        /(\^|\\\/)?\\\*$/,
+        (_6, p1) => {
+          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+          return `${prefix}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var regexCache = /* @__PURE__ */ Object.create(null);
+    var makeRegex = (pattern, ignoreCase) => {
+      let source = regexCache[pattern];
+      if (!source) {
+        source = REPLACERS.reduce(
+          (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+          pattern
+        );
+        regexCache[pattern] = source;
+      }
+      return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+    };
+    var isString2 = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString2(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+    var IgnoreRule = class {
+      constructor(origin, pattern, negative, regex) {
+        this.origin = origin;
+        this.pattern = pattern;
+        this.negative = negative;
+        this.regex = regex;
+      }
+    };
+    var createRule = (pattern, ignoreCase) => {
+      const origin = pattern;
+      let negative = false;
+      if (pattern.indexOf("!") === 0) {
+        negative = true;
+        pattern = pattern.substr(1);
+      }
+      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regex = makeRegex(pattern, ignoreCase);
+      return new IgnoreRule(
+        origin,
+        pattern,
+        negative,
+        regex
+      );
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path4, originalPath, doThrow) => {
+      if (!isString2(path4)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path4) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path4)) {
+        const r2 = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r2} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path4) => REGEX_TEST_INVALID_PATH.test(path4);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p4) => p4;
+    var Ignore2 = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = [];
+        this._ignoreCase = ignoreCase;
+        this._allowRelativePaths = allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      _addPattern(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules);
+          this._added = true;
+          return;
+        }
+        if (checkPattern(pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString2(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._addPattern, this);
+        if (this._added) {
+          this._initCache();
+        }
+        return this;
+      }
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      _testOne(path4, checkUnignored) {
+        let ignored = false;
+        let unignored = false;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule.regex.test(path4);
+          if (matched) {
+            ignored = !negative;
+            unignored = negative;
+          }
+        });
+        return {
+          ignored,
+          unignored
+        };
+      }
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path4 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path4,
+          originalPath,
+          this._allowRelativePaths ? RETURN_FALSE : throwError
+        );
+        return this._t(path4, cache, checkUnignored, slices);
+      }
+      _t(path4, cache, checkUnignored, slices) {
+        if (path4 in cache) {
+          return cache[path4];
+        }
+        if (!slices) {
+          slices = path4.split(SLASH);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path4] = this._testOne(path4, checkUnignored);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path4] = parent.ignored ? parent : this._testOne(path4, checkUnignored);
+      }
+      ignores(path4) {
+        return this._test(path4, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path4) => !this.ignores(path4);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      test(path4) {
+        return this._test(path4, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore2(options);
+    var isPathValid = (path4) => checkPath(path4 && checkPath.convert(path4), path4, RETURN_FALSE);
+    factory.isPathValid = isPathValid;
+    factory.default = factory;
+    module2.exports = factory;
+    if (typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")) {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path4) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path4) || isNotRelative(path4);
+    }
+  }
+});
+
 // node_modules/openai/node_modules/axios/lib/helpers/bind.js
 var require_bind = __commonJS({
   "node_modules/openai/node_modules/axios/lib/helpers/bind.js"(exports, module2) {
@@ -15482,7 +15763,7 @@ function G3(t, e2) {
 // package.json
 var package_default = {
   name: "opencommit",
-  version: "1.1.14",
+  version: "1.1.16",
   description: "GPT CLI to auto-generate impressive commits in 1 second. Killing lame commits with AI \u{1F92F}\u{1F52B}",
   keywords: [
     "git",
@@ -15546,6 +15827,7 @@ var package_default = {
     chalk: "^5.2.0",
     cleye: "^1.3.2",
     execa: "^7.0.0",
+    ignore: "^5.2.4",
     ini: "^3.0.1",
     inquirer: "^9.1.4",
     openai: "^3.2.1"
@@ -17671,6 +17953,8 @@ function execa(file, args, options) {
 }
 
 // src/utils/git.ts
+var import_fs2 = require("fs");
+var import_ignore = __toESM(require_ignore(), 1);
 var assertGitRepo = async () => {
   try {
     await execa("git", ["rev-parse"]);
@@ -17678,6 +17962,14 @@ var assertGitRepo = async () => {
     throw new Error(error);
   }
 };
+var getOpenCommitIgnore = () => {
+  const ig = (0, import_ignore.default)();
+  try {
+    ig.add((0, import_fs2.readFileSync)(".opencommitignore").toString().split("\n"));
+  } catch (e2) {
+  }
+  return ig;
+};
 var getStagedFiles = async () => {
   const { stdout: files } = await execa("git", [
     "diff",
@@ -17686,7 +17978,12 @@ var getStagedFiles = async () => {
   ]);
   if (!files)
     return [];
-  return files.split("\n").sort();
+  const filesList = files.split("\n");
+  const ig = getOpenCommitIgnore();
+  const allowedFiles = filesList.filter((file) => !ig.ignores(file));
+  if (!allowedFiles)
+    return [];
+  return allowedFiles.sort();
 };
 var getChangedFiles = async () => {
   const { stdout: modified } = await execa("git", ["ls-files", "--modified"]);
@@ -17724,17 +18021,18 @@ ${lockFiles.join(
   const { stdout: diff } = await execa("git", [
     "diff",
     "--staged",
+    "--",
     ...filesWithoutLocks
   ]);
   return diff;
 };
 
 // src/commands/githook.ts
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 var HOOK_NAME = "prepare-commit-msg";
 var SYMLINK_URL = `.git/hooks/${HOOK_NAME}`;
 var isHookCalled = process.argv[1].endsWith(`/${SYMLINK_URL}`);
-var isHookExists = (0, import_fs2.existsSync)(SYMLINK_URL);
+var isHookExists = (0, import_fs3.existsSync)(SYMLINK_URL);
 var hookCommand = G3(
   {
     name: "hook" /* hook */,
@@ -20687,7 +20985,7 @@ var translation = i18n[config2?.language || "en"];
 var INIT_MESSAGES_PROMPT = [
   {
     role: import_openai2.ChatCompletionRequestMessageRoleEnum.System,
-    content: `You are to act as the author of a commit message in git. Your mission is to create clean and comprehensive commit messages in the conventional commit convention. I'll send you an output of 'git diff --staged' command, and you convert it into a commit message. ${config2?.emoji ? "Use Gitmoji convention to preface the commit" : "Do not preface the commit with anything"}, use the present tense. ${config2?.description ? `Add a short description of what commit is about after the commit message. Don't start it with "This commit", just describe the changes.` : "Don't add any descriptions to the commit, only commit message."} Use ${translation.localLanguage} to answer.}`
+    content: `You are to act as the author of a commit message in git. Your mission is to create clean and comprehensive commit messages in the conventional commit convention. I'll send you an output of 'git diff --staged' command, and you convert it into a commit message. ${config2?.emoji ? "Use Gitmoji convention to preface the commit" : "Do not preface the commit with anything"}, use the present tense. ${config2?.description ? `Add a short description of what commit is about after the commit message. Don't start it with "This commit", just describe the changes.` : "Don't add any descriptions to the commit, only commit message."} Use ${translation.localLanguage} to answer.`
   },
   {
     role: import_openai2.ChatCompletionRequestMessageRoleEnum.User,
@@ -20842,7 +21140,7 @@ var trytm = async (promise) => {
 };
 
 // src/commands/commit.ts
-var generateCommitMessageFromGitDiff = async (diff) => {
+var generateCommitMessageFromGitDiff = async (diff, extraArgs2) => {
   await assertGitRepo();
   const commitSpinner = le();
   commitSpinner.start("Generating the commit message");
@@ -20867,7 +21165,12 @@ ${source_default.grey("\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2
     message: "Confirm the commit message"
   });
   if (isCommitConfirmedByUser && !eD2(isCommitConfirmedByUser)) {
-    const { stdout } = await execa("git", ["commit", "-m", commitMessage]);
+    const { stdout } = await execa("git", [
+      "commit",
+      "-m",
+      commitMessage,
+      ...extraArgs2
+    ]);
     ce(`${source_default.green("\u2714")} successfully committed`);
     ce(stdout);
     const isPushConfirmedByUser = await Q3({
@@ -20884,7 +21187,7 @@ ${source_default.grey("\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2
   } else
     ce(`${source_default.gray("\u2716")} process cancelled`);
 };
-async function commit(isStageAllFlag = false) {
+async function commit(extraArgs2 = [], isStageAllFlag = false) {
   if (isStageAllFlag) {
     const changedFiles2 = await getChangedFiles();
     if (changedFiles2)
@@ -20913,7 +21216,7 @@ async function commit(isStageAllFlag = false) {
       message: "Do you want to stage all files and generate commit message?"
     });
     if (isStageAllAndCommitConfirmedByUser && !eD2(isStageAllAndCommitConfirmedByUser)) {
-      await commit(true);
+      await commit(extraArgs2, true);
       process.exit(1);
     }
     if (stagedFiles.length === 0 && changedFiles.length > 0) {
@@ -20928,7 +21231,7 @@ async function commit(isStageAllFlag = false) {
         process.exit(1);
       await gitAdd({ files });
     }
-    await commit(false);
+    await commit(extraArgs2, false);
     process.exit(1);
   }
   stagedFilesSpinner.stop(
@@ -20936,7 +21239,10 @@ async function commit(isStageAllFlag = false) {
 ${stagedFiles.map((file) => `  ${file}`).join("\n")}`
   );
   const [, generateCommitError] = await trytm(
-    generateCommitMessageFromGitDiff(await getDiff({ files: stagedFiles }))
+    generateCommitMessageFromGitDiff(
+      await getDiff({ files: stagedFiles }),
+      extraArgs2
+    )
   );
   if (generateCommitError) {
     ce(`${source_default.red("\u2716")} ${generateCommitError}`);
@@ -20946,7 +21252,7 @@ ${stagedFiles.map((file) => `  ${file}`).join("\n")}`
 }
 
 // src/cli.ts
-var rawArgv = process.argv.slice(2);
+var extraArgs = process.argv.slice(2);
 Z2(
   {
     version: package_default.version,
@@ -20960,10 +21266,10 @@ Z2(
     if (isHookCalled) {
       prepareCommitMessageHook();
     } else {
-      commit();
+      commit(extraArgs);
     }
   },
-  rawArgv
+  extraArgs
 );
 /*!
  * mime-db

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencommit",
-  "version": "1.1.15",
+  "version": "1.1.17",
   "description": "GPT CLI to auto-generate impressive commits in 1 second. Killing lame commits with AI 🤯🔫",
   "keywords": [
     "git",
@@ -64,6 +64,7 @@
     "chalk": "^5.2.0",
     "cleye": "^1.3.2",
     "execa": "^7.0.0",
+    "ignore": "^5.2.4",
     "ini": "^3.0.1",
     "inquirer": "^9.1.4",
     "openai": "^3.2.1"