@cmdwuzntfnd/bitecli 0.1.20

package/template/src/bitecli.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { strings as s } from "#i18n";
+import {
+  commandConfig,
+  setDebug,
+  appState,
+  red,
+  isNodeError,
+  exitOne,
+} from "#meta";
+import "#defaultvals"; // Import for side effects (config generation)
+import type { CommandModule } from "#types";
+
+commandConfig._default = commandConfig.help;
+let parsedGlobalArgs: ReturnType<typeof parseArgs>;
+
+async function applyCommand(): Promise<void> {
+  const commandAlias =
+    (parsedGlobalArgs.positionals[0] as string) ?? "_default";
+  const commandModuleName = commandConfig[commandAlias];
+  if (!commandModuleName) {
+    exitOne();
+    console.error(red(s.errors.commandNotImplemented));
+    return;
+  }
+  const modulePath = `#commands/${commandModuleName}`;
+  const { default: CommandClass } = (await import(modulePath)) as CommandModule;
+  const commandInstance = new CommandClass();
+  await commandInstance.execute(process.argv.slice(2));
+}
+
+async function main(): Promise<number> {
+  try {
+    // Parse global flags like --version before handing off to commands
+    parsedGlobalArgs = parseArgs({
+      strict: false, // Allow command-specific options
+      args: process.argv.slice(2),
+    });
+    if (parsedGlobalArgs.values.version) {
+      console.log(red(`${appState.P_NAME}: ${appState.P_VERSION}`));
+      return 0;
+    }
+    if (parsedGlobalArgs.values.debug) {
+      setDebug();
+    }
+    await applyCommand();
+    return 0;
+  } catch (err: unknown) {
+    exitOne();
+    if (isNodeError(err)) {
+      console.error(red(err.message));
+      if (isNodeError(err.cause)) {
+        console.error(red(`>Cause: ${err.cause.message ?? String(err.cause)}`));
+      }
+      if (parsedGlobalArgs?.values.debug && err.stack) {
+        console.error(err.stack);
+      }
+    } else {
+      console.error(red(String(err)));
+    }
+    return 1;
+  }
+}
+
+await main();

package/template/src/commands/cocommand.ts

@@ -0,0 +1,294 @@
+import type { Command, CommandConstructor, PositionalCompletion } from "#types";
+import { commandConfig, createError, P_NAME, isNodeError } from "#meta";
+import { strings as s } from "#i18n";
+import { GREETING } from "#defaultvals";
+
+// this is where you add template substitutions for help texts
+// e.g. if a help text contains "{{ .Greeting }}", it will be replaced with the value of GREETING
+// from #defaultvals.ts
+// Add more entries as needed for other commands and placeholders
+// The structure is: { commandName: { Placeholder: value, ... }, ... }
+const replacements: Record<string, Record<string, string>> = {
+  hello: { Greeting: GREETING },
+};
+
+function applyReplacements(
+  template: string,
+  commandReplacements: Record<string, string> | undefined,
+): string {
+  if (!template || !commandReplacements) {
+    return template;
+  }
+  let result = template;
+  for (const [key, value] of Object.entries(commandReplacements)) {
+    const placeholder = `{{ .${key} }}`;
+    result = result.replace(new RegExp(RegExp.escape(placeholder), "g"), value);
+  }
+  return result;
+}
+
+export default class CoCommand implements Command {
+  static allowPositionals = false;
+  static positionalCompletion = "none" as const;
+  static options = {};
+  async execute(argv: string[]): Promise<number> {
+    const script = await this.generateBashCompletionScript();
+    console.log(script);
+    return 0;
+  }
+
+  private async generateBashCompletionScript(): Promise<string> {
+    const programName = P_NAME || "batchbite";
+
+    const subcommands = Object.keys(commandConfig)
+      .filter((c) => c !== "_default")
+      .sort();
+    const allSubcommands = [...subcommands].sort();
+    const globalOpts = ["--version", "--help"].sort().join(" ");
+
+    let caseBlock = "";
+
+    const sortedCommandConfigEntries = Object.entries(commandConfig).sort(
+      ([a], [b]) => a.localeCompare(b),
+    );
+
+    for (const [alias, moduleName] of sortedCommandConfigEntries) {
+      if (alias === "_default") continue;
+
+      const modulePath = `#commands/${moduleName}`;
+      try {
+        const { default: CommandClass } = (await import(modulePath)) as {
+          default: CommandConstructor;
+        };
+
+        const commandsHelp = s.help.commands;
+        const cmdHelpSection =
+          commandsHelp[alias as keyof typeof commandsHelp] ??
+          commandsHelp[moduleName as keyof typeof commandsHelp];
+
+        let helpFlags: Record<string, string> | undefined;
+        if (
+          cmdHelpSection &&
+          "flags" in cmdHelpSection &&
+          cmdHelpSection.flags
+        ) {
+          helpFlags = cmdHelpSection.flags;
+        }
+
+        caseBlock += this.generateCaseForCommand(
+          alias,
+          CommandClass,
+          helpFlags,
+        );
+      } catch (err) {
+        if (isNodeError(err)) {
+          caseBlock += `  # failed to load command ${alias} (${moduleName}): ${String(
+            err.message ?? err,
+          )}\n`;
+          createError(s.errors.coError.replace("{{ .Command }}", alias), {
+            cause: err,
+          });
+        } else {
+          createError(s.errors.unknownErrorOccurred, { cause: err });
+        }
+      }
+    }
+
+    const script = `#!/usr/bin/env bash
+# Bash completion for ${programName}
+# Generated on: ${new Date().toISOString()}
+
+_${programName}_completions() {
+  local cur prev words cword
+  _get_comp_words_by_ref -n : cur prev words cword
+
+  local subcommands="${allSubcommands.join(" ")}"
+  local global_opts="${globalOpts}"
+
+  # Helpers: file/dir completion that preserves tilde
+  _bb_filedir() {
+    local expanded_cur="\${cur/#\~/$HOME}"
+    COMPREPLY=( $(compgen -f -- "\${expanded_cur}") )
+    if [[ "\${cur}" == "~"* && "\${#COMPREPLY[@]}" -gt 0 ]]; then
+      for i in "\${!COMPREPLY[@]}"; do
+        COMPREPLY[i]="~/\${COMPREPLY[i]#$HOME/}"
+      done
+    fi
+  }
+
+  _bb_dirdir() {
+    local expanded_cur="\${cur/#\~/$HOME}"
+    COMPREPLY=( $(compgen -d -- "\${expanded_cur}") )
+    if [[ "\${cur}" == "~"* && "\${#COMPREPLY[@]}" -gt 0 ]]; then
+      for i in "\${!COMPREPLY[@]}"; do
+        COMPREPLY[i]="~/\${COMPREPLY[i]#$HOME/}"
+      done
+    fi
+  }
+
+  # Top-level: if completing the program itself (first arg)
+  if [[ $cword -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${subcommands} \${global_opts}" -- "\${cur}") )
+    return 0
+  fi
+
+  case "\${words[1]}" in
+${caseBlock}
+    help)
+      COMPREPLY=( $(compgen -W "\${subcommands}" -- "\${cur}") )
+      ;;
+    *)
+      COMPREPLY=()
+      ;;
+  esac
+
+  return 0
+}
+
+complete -F _${programName}_completions ${programName}
+`;
+    return script;
+  }
+
+  private generateCaseForCommand(
+    alias: string,
+    CommandClass: CommandConstructor,
+    helpFlags?: Record<string, string>,
+  ): string {
+    const options = CommandClass.options ?? {};
+    const allowPositionals = CommandClass.allowPositionals ?? false;
+    const positionalCompletion = CommandClass.positionalCompletion ?? "none";
+
+    const longOpts = Object.keys(options).map((o) => `--${o}`);
+    const shortOpts = Object.values(options)
+      .map((cfg) => (cfg.short ? `-${cfg.short}` : ""))
+      .filter(Boolean);
+
+    const descEntries: string[] = [];
+    const optsWords: string[] = [];
+
+    for (const [longName, cfg] of Object.entries(options)) {
+      const longOpt = `--${longName}`;
+      optsWords.push(longOpt);
+
+      let desc = (helpFlags && helpFlags[longName]) || "";
+      const commandReplacements = replacements[alias];
+      desc = applyReplacements(desc, commandReplacements);
+
+      const safeKey = escapeForSingleQuotedBash(longOpt);
+      const safeVal = escapeForDoubleQuotedBash(desc);
+
+      descEntries.push(`_BB_DESC['${safeKey}']="${safeVal}"`);
+
+      if (cfg.short) {
+        const shortOpt = `-${cfg.short}`;
+        optsWords.push(shortOpt);
+        descEntries.push(
+          `_BB_DESC['${escapeForSingleQuotedBash(shortOpt)}']="${safeVal}"`,
+        );
+      }
+    }
+
+    const allOpts = Array.from(new Set([...longOpts, ...shortOpts]))
+      .sort()
+      .join(" ");
+
+    const valueOpts = Object.entries(options)
+      .filter(([, cfg]) => cfg.type === "string")
+      .flatMap(([long, cfg]) => {
+        const arr = [`--${long}`];
+        if (cfg.short) arr.push(`-${cfg.short}`);
+        return arr;
+      })
+      .map((v) => v.replace(/(["'\\])/g, "\\$1"));
+
+    const valueOptsJoined = valueOpts.join(" ");
+
+    const positionalHandler = this.getPositionalHandler(
+      allowPositionals,
+      positionalCompletion,
+    );
+
+    const block = `
+    ${alias})
+      # Option words for ${alias}
+      local _opts="${allOpts}"
+      # associative array _BB_DESC maps option -> description
+      declare -A _BB_DESC=()
+      ${descEntries.length > 0 ? descEntries.join("\n      ") : "# no descriptions available"}
+
+      # If previous argument is one that requires a value, provide file/dir completions
+      ${
+        valueOpts.length > 0
+          ? `
+      if [[ " ${valueOptsJoined} " == *" \${prev} "* ]]; then
+        ${positionalHandler === "_bb_filedir" ? "_bb_filedir" : positionalHandler === "_bb_dirdir" ? "_bb_dirdir" : "# no specific value completion"}
+        return 0
+      fi
+      `
+          : ""
+      }
+
+      # If current token looks like an option, complete options
+      if [[ "\${cur}" == -* ]]; then
+        COMPREPLY=( $(compgen -W "\${_opts}" -- "\${cur}") )
+
+        # If bash is asking for a listing (double-Tab), COMP_TYPE==63. Print descriptions then clear COMPREPLY
+        if [[ -n "\${COMP_TYPE-}" && "\${COMP_TYPE}" -eq 63 ]]; then
+          printf "\\n"
+          local k d
+          for k in "\${COMPREPLY[@]}"; do
+            d="\${_BB_DESC[\${k}]:-}"
+            if [[ -n "\${d}" ]]; then
+              printf "%-28s %s\n" "\${k}" "\${d}"
+            else
+              printf "%s\n" "\${k}"
+            fi
+          done
+          COMPREPLY=()
+          return 0
+        fi
+
+        # Normal completion: return matching words so Tab completes
+        return 0
+      else
+        # not an option token -> positional completion (file/dir/none)
+        ${positionalHandler}
+      fi
+      ;;
+`;
+
+    return block;
+  }
+
+  private getPositionalHandler(
+    allow: boolean,
+    type: PositionalCompletion,
+  ): string {
+    if (!allow) return "COMPREPLY=()";
+    switch (type) {
+      case "file":
+        return "_bb_filedir";
+      case "directory":
+        return "_bb_dirdir";
+      case "none":
+      default:
+        return "COMPREPLY=()";
+    }
+  }
+}
+
+function escapeForSingleQuotedBash(str: string | undefined): string {
+  if (!str) return "";
+  return str.replace(/'/g, `'"'"'`);
+}
+
+function escapeForDoubleQuotedBash(str: string | undefined): string {
+  if (!str) return "";
+  return str
+    .replace(/\\/g, `\\\\`)
+    .replace(/"/g, `\\"`)
+    .replace(/\$/g, `\\$`)
+    .replace(/`/g, "\\`")
+    .replace(/\r?\n/g, "\\n");
+}

package/template/src/commands/configcommand.ts

@@ -0,0 +1,151 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { createInterface } from "node:readline/promises";
+import { generateLocaleList, isValidLocale, strings as s } from "#i18n";
+import {
+  appState,
+  generateHelpText,
+  red,
+  yellowBright,
+  exitOne,
+  isNodeError,
+} from "#meta";
+import { spawn } from "node:child_process";
+import type { Command } from "#types";
+
+export function openWith(filePath: string) {
+  const editor = process.env.EDITOR;
+
+  if (!editor) {
+    console.warn(yellowBright(`${s.errors.editorNotFound}`));
+    return;
+  }
+
+  const child = spawn(editor, [filePath], {
+    stdio: "inherit",
+  });
+
+  child.on("error", (err) => {
+    console.error(
+      red(
+        `${s.errors.editorLaunchFailed.replace("{{ .ErrorMessage }}", err.message)}`,
+      ),
+    );
+  });
+}
+
+export default class CfgCommand implements Command {
+  static allowPositionals = false;
+  static positionalCompletion = "none" as const;
+  static options = {
+    help: { type: "boolean", short: "h" },
+    edit: { type: "boolean", short: "e" },
+    remove: { type: "boolean", short: "r" },
+    lang: { type: "string", short: "l" },
+  } as const;
+  async execute(argv: string[]): Promise<number> {
+    const { values: argValues, positionals } = parseArgs({
+      args: argv.slice(1),
+      allowPositionals: false,
+      strict: true,
+      options: (this.constructor as typeof CfgCommand).options,
+    });
+
+    const hasArguments =
+      Object.keys(argValues).some((key) => {
+        const value = argValues[key as keyof typeof argValues];
+        if (typeof value === "boolean") {
+          return value === true;
+        }
+        if (typeof value === "string") {
+          return value !== "";
+        }
+        return value !== undefined && value !== null;
+      }) || positionals.length > 1;
+
+    if (!hasArguments || argValues.help) {
+      const replacements = {
+        LocaleList: generateLocaleList(),
+      };
+      const helpText = generateHelpText(
+        s.help.commands.cfg,
+        (this.constructor as typeof CfgCommand).options,
+        replacements,
+      );
+      console.log(helpText);
+      return 0;
+    }
+
+    const cfgPath = path.join(appState.STATE_DIR, "defaultvals.js");
+    const localePath = path.join(appState.STATE_DIR, "locale.json");
+
+    if (argValues.edit) {
+      console.log(`${cfgPath}`);
+      openWith(cfgPath);
+      return 0;
+    }
+    if (argValues.remove) {
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+      console.log(red(`${cfgPath}`));
+
+      const localeExists = fs.existsSync(localePath);
+      if (localeExists) {
+        console.log(red(`${localePath}`));
+      }
+
+      const answer = await rl.question(s.messages.deletionConfirm);
+      rl.close();
+      if (answer.trim().toLowerCase() === s.messages.yN) {
+        await fs.promises.unlink(cfgPath);
+        if (localeExists) {
+          await fs.promises.unlink(localePath);
+        }
+        console.log(yellowBright(s.messages.cfgDeletedSuccessfully));
+        return 0;
+      }
+      console.log(s.messages.deletionAborted);
+      return 0;
+    }
+    const lang = argValues.lang;
+    if (lang) {
+      if (isValidLocale(lang)) {
+        const localeData = { locale: argValues.lang };
+        try {
+          await fs.promises.writeFile(
+            localePath,
+            JSON.stringify(localeData, null, 2),
+            "utf8",
+          );
+          console.log(
+            s.messages.localeSuccessfullyChanged.replace(
+              "{{ .Locale }}",
+              `${argValues.lang}`,
+            ),
+          );
+          return 0;
+        } catch (err: unknown) {
+          if (isNodeError(err)) {
+            exitOne();
+            console.error(
+              red(
+                s.errors.failedToWriteLocale.replace(
+                  "{{ .ErrorMessage }}",
+                  `${err?.message}`,
+                ),
+              ),
+            );
+            return 1;
+          }
+        }
+      } else {
+        console.error(red(`Invalid locale: ${lang}`));
+        return 1;
+      }
+    }
+    return 0;
+  }
+}

package/template/src/commands/hellocommand.ts

@@ -0,0 +1,43 @@
+import { parseArgs } from "node:util";
+import { strings as s } from "#i18n";
+import { generateHelpText, createError } from "#meta";
+import { GREETING } from "#defaultvals";
+import type { Command } from "#types";
+
+export default class HelloCommand implements Command {
+  // Static properties are used for metadata by help and completion generators
+  static allowPositionals = false;
+  static positionalCompletion = "none" as const;
+  static options = {
+    help: { type: "boolean", short: "h" },
+    name: { type: "string", short: "n" },
+  } as const;
+
+  async execute(argv: string[]): Promise<number> {
+    const { values: argValues } = parseArgs({
+      args: argv.slice(1), // slice(1) removes the cmd, useful for disabling positionals
+      allowPositionals: false,
+      strict: true,
+      options: (this.constructor as typeof HelloCommand).options,
+    });
+    const helloHelp = () => {
+      const helpText = generateHelpText(
+        s.help.commands.hello,
+        (this.constructor as typeof HelloCommand).options,
+        { Greeting: GREETING },
+      );
+      console.log(helpText);
+    };
+    if (argValues.help) {
+      helloHelp();
+      return 0;
+    }
+
+    /*     if (!argValues.x) {
+      helloHelp();
+      throw createError(s.errors.xRequired, { code: "X_REQUIRED" });
+    }
+ */
+    return 0;
+  }
+}

package/template/src/commands/helpcommand.ts

@@ -0,0 +1,21 @@
+import { parseArgs } from "node:util";
+import { strings as s } from "#i18n";
+import { generateGenericHelpText } from "#meta";
+import type { Command } from "#types";
+
+export default class HelpCommand implements Command {
+  static allowPositionals = false;
+  static positionalCompletion = "none" as const;
+  static options = {};
+  async execute(argv: string[]): Promise<number> {
+    parseArgs({
+      args: argv.slice(1),
+      allowPositionals: false,
+      strict: true,
+      options: (this.constructor as typeof HelpCommand).options,
+    });
+    const helpText = generateGenericHelpText(s.help.generic);
+    console.log(helpText);
+    return 0;
+  }
+}

package/template/src/defaultvals.ts

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { strings as s } from "#i18n";
+import { appState, createError } from "#meta";
+import type * as Template from "#templatevals";
+
+const USER_CONFIG_FILENAME = "defaultvals.js";
+const USER_CONFIG_DIR = appState.STATE_DIR;
+const USER_CONFIG_PATH = path.join(USER_CONFIG_DIR, USER_CONFIG_FILENAME);
+
+let finalConfig: typeof Template;
+
+try {
+  // If the user's config file doesn't exist, create it from the template.
+  if (!fs.existsSync(USER_CONFIG_PATH)) {
+    console.log(
+      s.messages.userConfigNotFound.replace(
+        "{{ .UserConfigPath }}",
+        USER_CONFIG_PATH,
+      ),
+    );
+    fs.mkdirSync(USER_CONFIG_DIR, { recursive: true });
+
+    const templateURL = await import.meta.resolve("#templatevals");
+    const templatePath = fileURLToPath(templateURL);
+    const templateContent = fs.readFileSync(templatePath, "utf8");
+
+    const userFileHeader = `/**
+ * This is your user-specific configuration file.
+ * It was automatically generated from the application's template.
+ * You can safely edit the values in this file to customize your experience.
+ * Your changes will be preserved across application updates.
+ * If you delete this file, a new one will be generated on the next launch.
+ */\n\n`;
+
+    fs.writeFileSync(
+      USER_CONFIG_PATH,
+      userFileHeader + templateContent,
+      "utf8",
+    );
+    console.log(s.messages.cfgCreatedSuccessfully);
+  }
+
+  // Import the user's configuration (or the newly created one).
+  finalConfig = (await import(
+    pathToFileURL(USER_CONFIG_PATH).href
+  )) as typeof Template;
+} catch (err: unknown) {
+  throw createError(
+    s.errors.cfgCouldNotBeLoaded.replace(
+      "{{ .UserConfigPath }}",
+      USER_CONFIG_PATH,
+    ),
+    { cause: err, code: "CONFIG_LOAD_FAILED" },
+  );
+}
+
+// Export values from the user's configuration file.
+export const { GREETING } = finalConfig;

package/template/src/globals.d.ts

@@ -0,0 +1,11 @@
+// global.d.ts
+export {};
+
+declare global {
+  interface RegExpConstructor {
+    /**
+     * Escapes special characters in a string so it can be used literally in a RegExp.
+     */
+    escape(str: string): string;
+  }
+}