@buildepicshit/cli 0.0.6 → 0.0.8

package/dist/bes.js

@@ -3325,6 +3325,348 @@ var require_commander = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/omelette@0.4.17/node_modules/omelette/src/omelette.js
+var require_omelette = __commonJS({
+  "../../node_modules/.pnpm/omelette@0.4.17/node_modules/omelette/src/omelette.js"(exports, module) {
+    (function() {
+      var EventEmitter, Omelette, depthOf, fs, os2, path, removeSubstring, hasProp = {}.hasOwnProperty;
+      ({ EventEmitter } = __require("events"));
+      path = __require("path");
+      fs = __require("fs");
+      os2 = __require("os");
+      depthOf = function(object) {
+        var depth, key, level;
+        level = 1;
+        for (key in object) {
+          if (!hasProp.call(object, key)) continue;
+          if (typeof object[key] === "object") {
+            depth = depthOf(object[key]) + 1;
+            level = Math.max(depth, level);
+          }
+        }
+        return level;
+      };
+      removeSubstring = function(haystack, needle) {
+        return haystack.replace(new RegExp(needle.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"), "g"), "");
+      };
+      Omelette = (function() {
+        var log;
+        class Omelette2 extends EventEmitter {
+          constructor() {
+            var isFish, isZsh, ref;
+            super();
+            this.asyncs = 0;
+            this.compgen = process.argv.indexOf("--compgen");
+            this.install = process.argv.indexOf("--completion") > -1;
+            this.installFish = process.argv.indexOf("--completion-fish") > -1;
+            isZsh = process.argv.indexOf("--compzsh") > -1;
+            isFish = process.argv.indexOf("--compfish") > -1;
+            this.isDebug = process.argv.indexOf("--debug") > -1;
+            this.fragment = parseInt(process.argv[this.compgen + 1]) - (isZsh ? 1 : 0);
+            this.line = process.argv.slice(this.compgen + 3).join(" ");
+            this.word = (ref = this.line) != null ? ref.trim().split(/\s+/).pop() : void 0;
+            ({ HOME: this.HOME, SHELL: this.SHELL } = process.env);
+            ({ platform: this.platform } = process);
+            this.mainProgram = function() {
+            };
+          }
+          setProgram(programs) {
+            programs = programs.split("|");
+            [this.program] = programs;
+            return this.programs = programs.map(function(program3) {
+              return program3.replace(/[^A-Za-z0-9\.\_\-]/g, "");
+            });
+          }
+          setFragments(...fragments1) {
+            this.fragments = fragments1;
+          }
+          generate() {
+            var data;
+            data = {
+              before: this.word,
+              fragment: this.fragment,
+              line: this.line,
+              reply: this.reply
+            };
+            this.emit("complete", this.fragments[this.fragment - 1], data);
+            this.emit(this.fragments[this.fragment - 1], data);
+            this.emit(`$${this.fragment}`, data);
+            if (this.asyncs === 0) {
+              return process.exit();
+            }
+          }
+          reply(words = []) {
+            var writer;
+            writer = function(options) {
+              console.log(typeof options.join === "function" ? options.join(os2.EOL) : void 0);
+              return process.exit();
+            };
+            if (words instanceof Promise) {
+              return words.then(writer);
+            } else {
+              return writer(words);
+            }
+          }
+          next(handler) {
+            if (typeof handler === "function") {
+              return this.mainProgram = handler;
+            }
+          }
+          tree(objectTree = {}) {
+            var depth, i, level, ref;
+            depth = depthOf(objectTree);
+            for (level = i = 1, ref = depth; 1 <= ref ? i <= ref : i >= ref; level = 1 <= ref ? ++i : --i) {
+              this.on(`$${level}`, function({ fragment, reply, line }) {
+                var accessor, lastIndex, replies;
+                if (!/\s+/.test(line.slice(-1))) {
+                  lastIndex = -1;
+                }
+                accessor = (t) => line.split(/\s+/).slice(1, lastIndex).filter(Boolean).reduce((a, v) => a[v], t);
+                replies = fragment === 1 ? Object.keys(objectTree) : accessor(objectTree);
+                return reply((function(replies2) {
+                  if (replies2 instanceof Function) {
+                    return replies2();
+                  }
+                  if (replies2 instanceof Array) {
+                    return replies2;
+                  }
+                  if (replies2 instanceof Object) {
+                    return Object.keys(replies2);
+                  }
+                })(replies));
+              });
+            }
+            return this;
+          }
+          generateCompletionCode() {
+            var completions;
+            completions = this.programs.map((program3) => {
+              var completion;
+              completion = `_${program3}_completion`;
+              return `### ${program3} completion - begin. generated by omelette.js ###
+if type compdef &>/dev/null; then
+  ${completion}() {
+    compadd -- \`${this.program} --compzsh --compgen "\${CURRENT}" "\${words[CURRENT-1]}" "\${BUFFER}"\`
+  }
+  compdef ${completion} ${program3}
+elif type complete &>/dev/null; then
+  ${completion}() {
+    local cur prev nb_colon
+    _get_comp_words_by_ref -n : cur prev
+    nb_colon=$(grep -o ":" <<< "$COMP_LINE" | wc -l)
+
+    COMPREPLY=( $(compgen -W '$(${this.program} --compbash --compgen "$((COMP_CWORD - (nb_colon * 2)))" "$prev" "\${COMP_LINE}")' -- "$cur") )
+
+    __ltrim_colon_completions "$cur"
+  }
+  complete -F ${completion} ${program3}
+elif type compctl &>/dev/null; then
+  ${completion} () {
+    local cword line point si
+    read -Ac words
+    read -cn cword
+    read -l line
+    si="$IFS"
+    if ! IFS=$'
+' reply=($(${program3} --compzsh --compgen "\${cword}" "\${words[cword-1]}" "\${line}")); then
+      local ret=$?
+      IFS="$si"
+      return $ret
+    fi
+    IFS="$si"
+  }
+  compctl -K ${completion} ${program3}
+fi
+### ${program3} completion - end ###`;
+            });
+            if (this.isDebug) {
+              completions.push(this.generateTestAliases());
+            }
+            return completions.join(os2.EOL);
+          }
+          generateCompletionCodeFish() {
+            var completions;
+            completions = this.programs.map((program3) => {
+              var completion;
+              completion = `_${program3}_completion`;
+              return `### ${program3} completion - begin. generated by omelette.js ###
+function ${completion}
+  ${this.program} --compfish --compgen (count (commandline -poc)) (commandline -pt) (commandline -pb)
+end
+complete -f -c ${program3} -a '(${completion})'
+### ${program3} completion - end ###`;
+            });
+            if (this.isDebug) {
+              completions.push(this.generateTestAliases());
+            }
+            return completions.join(os2.EOL);
+          }
+          generateTestAliases() {
+            var debugAliases, debugUnaliases, fullPath;
+            fullPath = path.join(process.cwd(), this.program);
+            debugAliases = this.programs.map(function(program3) {
+              return `  alias ${program3}=${fullPath}`;
+            }).join(os2.EOL);
+            debugUnaliases = this.programs.map(function(program3) {
+              return `  unalias ${program3}`;
+            }).join(os2.EOL);
+            return `### test method ###
+omelette-debug-${this.program}() {
+${debugAliases}
+}
+omelette-nodebug-${this.program}() {
+${debugUnaliases}
+}
+### tests ###`;
+          }
+          checkInstall() {
+            if (this.install) {
+              log(this.generateCompletionCode());
+              process.exit();
+            }
+            if (this.installFish) {
+              log(this.generateCompletionCodeFish());
+              return process.exit();
+            }
+          }
+          getActiveShell() {
+            if (!this.SHELL) {
+              throw new Error("Shell could not be detected");
+            }
+            if (this.SHELL.match(/bash/)) {
+              return "bash";
+            } else if (this.SHELL.match(/zsh/)) {
+              return "zsh";
+            } else if (this.SHELL.match(/fish/)) {
+              return "fish";
+            } else {
+              throw new Error(`Unsupported shell: ${this.SHELL}`);
+            }
+          }
+          getDefaultShellInitFile() {
+            var fileAt, fileAtHome;
+            fileAt = function(root) {
+              return function(file) {
+                return path.join(root, file);
+              };
+            };
+            fileAtHome = fileAt(this.HOME);
+            switch (this.shell = this.getActiveShell()) {
+              case "bash":
+                return fileAtHome(this.platform === "darwin" ? ".bash_profile" : ".bashrc");
+              case "zsh":
+                return fileAtHome(".zshrc");
+              case "fish":
+                return fileAtHome(".config/fish/config.fish");
+            }
+          }
+          getCompletionBlock() {
+            var command, completionPath;
+            command = (function() {
+              switch (this.shell) {
+                case "bash":
+                  completionPath = path.join(this.HOME, `.${this.program}`, "completion.sh");
+                  return `source ${completionPath}`;
+                case "zsh":
+                  return `. <(${this.program} --completion)`;
+                case "fish":
+                  return `${this.program} --completion-fish | source`;
+              }
+            }).call(this);
+            if (command) {
+              return `
+# begin ${this.program} completion
+${command}
+# end ${this.program} completion
+`;
+            }
+          }
+          setupShellInitFile(initFile = this.getDefaultShellInitFile()) {
+            var completionPath, programFolder;
+            if (this.shell == null) {
+              this.shell = this.getActiveShell();
+            }
+            if (this.shell === "bash") {
+              programFolder = path.join(this.HOME, `.${this.program}`);
+              completionPath = path.join(programFolder, "completion.sh");
+              if (!fs.existsSync(programFolder)) {
+                fs.mkdirSync(programFolder);
+              }
+              fs.writeFileSync(completionPath, this.generateCompletionCode());
+            }
+            fs.appendFileSync(initFile, this.getCompletionBlock());
+            return process.exit();
+          }
+          cleanupShellInitFile(initFile = this.getDefaultShellInitFile()) {
+            var cleanedInitFile, completionPath, programFolder;
+            if (this.shell == null) {
+              this.shell = this.getActiveShell();
+            }
+            if (fs.existsSync(initFile)) {
+              cleanedInitFile = removeSubstring(fs.readFileSync(initFile, "utf8"), this.getCompletionBlock());
+              fs.writeFileSync(initFile, cleanedInitFile);
+            }
+            if (this.shell === "bash") {
+              programFolder = path.join(this.HOME, `.${this.program}`);
+              completionPath = path.join(programFolder, "completion.sh");
+              if (fs.existsSync(completionPath)) {
+                fs.unlinkSync(completionPath);
+              }
+              if (fs.existsSync(programFolder) && fs.readdirSync(programFolder).length === 0) {
+                fs.rmdirSync(programFolder);
+              }
+            }
+            return process.exit();
+          }
+          init() {
+            if (this.compgen > -1) {
+              return this.generate();
+            } else {
+              return this.mainProgram();
+            }
+          }
+          onAsync(event, handler) {
+            super.on(event, handler);
+            return this.asyncs += 1;
+          }
+        }
+        ;
+        ({ log } = console);
+        return Omelette2;
+      }).call(this);
+      module.exports = function(template, ...args) {
+        var _omelette, callback, callbacks, fragment, fragments, i, index, len, program3;
+        if (template instanceof Array && args.length > 0) {
+          [program3, callbacks] = [template[0].trim(), args];
+          fragments = callbacks.map(function(callback2, index2) {
+            return `arg${index2}`;
+          });
+        } else {
+          [program3, ...fragments] = template.split(/\s+/);
+          callbacks = [];
+        }
+        fragments = fragments.map(function(fragment2) {
+          return fragment2.replace(/^\<+|\>+$/g, "");
+        });
+        _omelette = new Omelette();
+        _omelette.setProgram(program3);
+        _omelette.setFragments(...fragments);
+        _omelette.checkInstall();
+        for (index = i = 0, len = callbacks.length; i < len; index = ++i) {
+          callback = callbacks[index];
+          fragment = `arg${index}`;
+          (function(callback2) {
+            return _omelette.on(fragment, function(...args2) {
+              return this.reply(callback2 instanceof Array ? callback2 : callback2(...args2));
+            });
+          })(callback);
+        }
+        return _omelette;
+      };
+    }).call(exports);
+  }
+});
+
 // ../../node_modules/.pnpm/commander@13.1.0/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
@@ -3342,6 +3684,17 @@ var {
   Help
 } = import_index.default;
 
+// src/completion.ts
+var import_omelette = __toESM(require_omelette(), 1);
+function setupCompletion(commandNames) {
+  const completion = (0, import_omelette.default)("bes <command>");
+  completion.on("command", ({ reply }) => {
+    reply([...commandNames, "--dry"]);
+  });
+  completion.init();
+  return completion;
+}
+
 // src/config-loader.ts
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
@@ -3975,6 +4328,12 @@ var program2 = new Command();
 program2.name("bes").description("Build Epic Shit \u2014 dev process manager CLI").version("0.1.0").option("--dry", "Resolve all tokens and print commands without executing");
 async function main() {
   const { root, commands } = await loadConfig();
+  const commandNames = Object.keys(commands);
+  const completion = setupCompletion(commandNames);
+  if (process.argv.includes("--setup-completion")) {
+    completion.setupShellInitFile();
+    return;
+  }
   for (const [name, fn] of Object.entries(commands)) {
     program2.command(name).description(`Run ${name}() from bes.config.ts`).action(async () => {
       const isDry = program2.opts().dry ?? false;